From 544a818940fd63ceb01bd8331d08dd7e6bd2cb53 Mon Sep 17 00:00:00 2001 From: jung-geun Date: Wed, 28 Jun 2023 23:29:27 +0900 Subject: [PATCH] =?UTF-8?q?23-06-28=20=EB=8B=A8=EC=88=9C=20=EC=97=85?= =?UTF-8?q?=EB=8D=B0=EC=9D=B4=ED=8A=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- history_plt/iris_0624_1.png | Bin 0 -> 299135 bytes iris.py | 12 +- mnist.py | 19 +- plt.ipynb | 140886 ++++++++++++++++++++++++++++++++- pso/optimizer.py | 30 +- pso/particle.py | 2 + readme.md | 2 +- 7 files changed, 140884 insertions(+), 67 deletions(-) create mode 100644 history_plt/iris_0624_1.png diff --git a/history_plt/iris_0624_1.png b/history_plt/iris_0624_1.png new file mode 100644 index 0000000000000000000000000000000000000000..50a37cfb080b0df97329053ada89903ccfdebc97 GIT binary patch literal 299135 zcmd?Rc|4VE_dZM|l}e(>cqb)g2$h+nLWPP#resQDo9C&Np$th#rUpYOW5&%!LNXPZ zhi#T|o2PAf*SWWz=ls}WQ+|+1G^L=V zpisOZtL7Lr-sKRbZCA80-4Y?)p=F;H`QU88+<6)WYQeWOyWV+n`dVLScxYC(U3S}( z6zihTvAWx+OmDo?{cFpOC;QGTC>$=b_`V>NrCMLJyuQ8zoBrU1((|gC$BVPQ(w22m z!o$L`d~J*F#ltSV2L7@aNMH6O6yl4%zWv1zMgG(Fw>?~(=u2n^6*nFF z3YI-C>PNb2_xVyq(p850b}5rC;`F*^xu0~^p~oql*eE<25|i&|P8(ozIAhtATX z#cpgRF^E;{#WVhb;|BAt8ad{|E(;GX1+x0#2_|12?_90lSgmL0z&AFQg{tc+>gcdN zJm8x7TP`Cnp>s$ zvE!Lt%`3$l#A0~P>(_sJ4%;s{7je)ZyV^QvhJz_At-147_tlEvS*KQI)~9I$#Yc}n zD*Y=yK0eB-;t;PM&b7q7%J4<(`dp$v^O;?-_40CZTU)ek_GD;0D8a!yg2dM58V{X) zz!YXQG2^1I?v}~>?A%{JFnCMRngiIK4q&@J~FIxOZDyx zS-cwQo_ec&jA%$|c1KTm2--?3(T&wv2j`lJTzp-7wwc3}d;4v6 z*C|=tN>f@xS66M5x?Wc0QeRVV(ecy&-9%59;|jhK_0 zYxC>6{PYCIBQiPpL=FaDm*%l%7AUo#vA$gIVcls}Iqx#@K2ZGrxoas&No}TV6k53! zgA(}Vy>@nXwhj)oj_%!sPFr(oV`XAbrWL-ZcO4RzaI3WyuT{s*97s-1Zp|_8@EqP) zX(^tGsCV@iu9pm{WOwnOoU|~mkEs=`WG#C{MZ+X)d=-xyj&@*Ik(y_aSsPJ_5H#36 zJ5<~6&0=w9d1i3yqaiq;0e7f zXft&6R+?@tEWR+TL1kyY&2lNNdr26d))G7?w%W$mcTSL#ljBH>uFEINt7c|nU`_*7 zA+=VOY`K+0k<+JN!BSTrN*ONG$axTv!CT$w*dMT#<1t~TCtP~x$LHK!!om`FtZM_s z&_inW-??r>H4zD^sdaHTk|--5w5FFb95@gGHq%KlG*c}=SX@;S=`y649g4&(bV!>u z^QvlS+!L3OAm*GA5utTl`=pi2oYrE-pFi*-x>?d=-L-#qxkhh&hH>jFEsOkk{Oraw z$Aw z`hBas0p~Y%ZQO*1hv)6*&o2esr=NY!$=TaV==I?k@;wsxCO!T6yLX(*;v-xK`ELKh z#Lkbk%svrteOOQ+zUnS>=FFKW$38z^-9n~T!RUK%NDAi~uDCV&0{G>(oWXP#MxY_p z)YbbJi4me!oW)>FmaK_*cZY5#?#4uwM6igyzPrb+zWRYVeVjR9CYs>tbN&4#x*gj- zeE87wLymS3Aggm?dAKIROVIn704@)|06$-8@K(T?a&TFtSCN#xew{9s*g3qNwb;Dl z>`;BIOwX$;0!1$)giR)`FARX;0^WJc?G=l|FEpyiL@RJLq$P}wj#5^(G&KpjE?F|O zuuw~eUp=<`T^;vjFkG+htq*%a^{h&)bhLh%_q@3cwkyi|JJ0E}XJ;x{FynK1y5;5N z0M3#z9+)lP))w*gaJ#SI3^FP!AD8LFMi*Ox)e72=w^G)pX=ZsND1<+-y?ps{w%vyxC+v@)7P5#>CZw5HoX*Qi3>lTpb&mfJPB zVp$x+WRN!;mm4 z@zxB;X6ELD z-;M+gM3}_%A}sbGcHozOB}$h&;AW%UTh=7!e#nu)IFLTF*kaP4(*mzC?oYpMU#)N3)M(p~^nBN7? z)p3}dLVc`qVupES0E@`Xe3}QF!R~N9_hrvDUH4_9r_Y{EI~QGjecDfNZB$*Nh&?er z{s{tAI!blDqW){vUJ|gf7nx+qCNYP+B%9atA9X=8vUf z^Jc!EJS1Ylnuc3BVPs^qc3&DWomkYIl7{>KQ8O!VG&yA@C)&Q<)T{YNcenDzi{+jZ zPo6wka>dDdsk^vHz-eGlFIqf<_i!c5i;Li0g~2ajU27FXj!gp)WjM_mU-D=AnY)JO z;MubJM(srT(Qxha*RNkM)};XOc!k_;@x~f~0Wi$=bmro!0B(s>N=j<&pkZs*GPg=h zP4dkY3h<&vlb!inFV!eZOq|{;HFvGT|B#%C2{$+jy`?$_Tv=cFvwQ-MxH3Tuz_@x% z_gBus{`W$cM2qj=zpv={G>t8EU`$3D;w5Lk9l=WC02-b?eTw@Tr>mo*<90Z2 zaZTm*>7A|9*&_FUeZaXb4$OWQLGSLgSoAd8$*uJIf_U`Me2d=j@ApAFu`M!jwJ zs|_;7HB1)yg9qK$#`Lo8{d`BMIxM}bUS>lwW^AYiLK)G|FVV&_P*F?MFXxQ|e4=Vx_9#p4|gha=>}<|5i5 zy|G+x17~bvVHKU&k;%!SFEj#%Yb*1oMMP#pVproZ@rBXR8-Q;H>#NJahCK8e;uI0i zy6LGDp}X+omhK`JR3|xmb+UNF9k*PIvEEo)T#P)i0wi{Nv3MgIzp=jP@@qr4I$Xd6 zhC%b(dMmaA%nT9E+)nFi3&!`B`P$m<%Y&=4u^R&jocQ?oKI&k@kgZ&J|I?kY@lsV8 zA*JgE5kK5!5*weA@+{wGc&3bFeP3?J+S|mTB0YI|YMY^&-hmL6NfEpK_O8Y1YHF4v z@!>+i6$%Op9KqKT*Gs0ZN9kQy@ZcDWWe8SyJkpp*uxI`@=~$$Tb~46kC<0e33NtPq zZZ}I~ODDjoZpFE|;43MqS*HkL0-PJ(w8|p0j*@D(ZY``0=I7@h@&sDjGw)1vlU$uD zb9?v|I6fkUu(DQw%{FjbVSvZfyuMvudZ*-XVZa`CR z|Lm7lFC95LdLKmtF+eQYiySI2*@G!#-q|Ka!mjOZJ<<5FOVuY`LH1y+x+?7V#c3i`^~)CNWON#lx7Q`CH9tdiB{Yx*ZOa*N$&H zC&`|el9Gb?-U%+^o77@wS+ziM%_~6zCUM*2K{D%(_&Hp3w8zXq6*|{ZHg#giVSoe0 ztxaGEIS%LWzC&Ya#e2s!+Sh>f4Qt_74gwarWiKc{8yg*MAH45bRGm$D@VXm$`IkJZ zqQvnmqHdPRj`_K{Ijsx=5L+H~9lHY}ot9gH+_-Jz%1jWeYr491xwv^gWTuNLsuv7% zGxJVeRHm$fMf!=+;tW28Uz>DL($R_LIez?<51aifCop|`qBzVTR1CZ}k-d283(fZ5 zxtSrphAM<)XAbQrwK?Yf(~c{*)UklvyYH~O&0WvBQ~D^{eH>wA4I! z^9={}CW-O%vYI%>knQ6la8$Rx!cG>LmDm8d4kabV2tmwrN;(RteS9%A&9z)3%!m{^e6B+T-z&!B=evt* zff?oO%oClj7wTtsLdg4;MK~h;o84*77P@K_H>X3>)ias3k*@+ z*;yXGfU&MN1HtmIfiScIgfs)b@Kq2NBb!px33F%QXc(Zdze%16R?edpiAo>$74mvpf(&GD8^l@3Q4m%#gAmIL{b>d?myB5lr4DM#U0%{QzA!PLZ4G|fFh^J;8se`|7b+7PMje1BE7uD{=s=ma4B%8O@VN;53-*&u@0TYP6ZVn7a_oLA z+BV%(kNEQCi+gpx$B&q8iBvQPnMzyht5C>3b$%J)TiHIlFk2Q$limsoznO-MB8QYG$x{xk|LLXdiy>% zD)+C9r6s<7`w)WS7ZQ_sULYcjf#9*%GtF(nY@3%Xl4_>e7Tjb=mT_&>gx-5)qUX_A=P)2ZH zl(5L_^>$aCPc2?|hVK=35qqh@m#VMCY>pwKxAVz)e>RCQP)433mjQkoaEa(#oHE$% zvxlW(x{?Er=|J!p2)KUY`W8{9}SnYXrVzJ?hz&zhK z;N@+=V1lGqj#Gfx#VY5$`_NPj1xcL1aeH#C{g%HPEglL26%t)I)~Bc;=&cV?kyb?0 zvEt-(%Z%={rs80-a)xK#eP z9KM=@m67C%ix)2@g&JdIdMX$F+oYV7|7a6*AF|;C5-_W(O47-Z{O$1f^>h2Umb2|BM1U0-#*6F&+aFoOx=&=!wSW=Ck)UUR1^9FSMK0`qCZo2gL+#EsRc-L)$Q|GG?z&+0fII zsizPggU7oXdA3$^smIGJriCf1k)?;(pawjPDHupV%h(xo5p4TU<-~6j7Q5Q-#0GVn zT5%LoTDZ7iBhHwG9TGD11zK$U)t7DvNJg`={MYqanT^J)vC>^H!@`&W$suCBFFhMk zKc{qk9F!1A8$gZMZ{>WD%(QFQt{VSC!Zjcn2>#w<7a)i&qMRJ6jSQ$B6ap;meUmop z4&YI*jPWFbbA1f~ULk>K@ckvvP%%inSA`;2rzB8cqja%T$AOM)hrFDSFXtU5}vPi`3qdVkp=`| zIun!}Zqc!iS)ObnMdLd0NsDQ3ionfp*VgDBTPG5R;cy;h-AgN)+5$Yl1~KwmA2p_f zanvMzylS^nQ^yl9PG4JbB{0QGR+}1j4io><9CQ0{c}Bk5pBtMpNa8w|h}%amRTULl zvzF8emqKtq2L*JmUc5*J8`l4bhQ9}#5s5WYv)S%5H#bLt3_9;flK_FS9_Tcn-%}9R z;jn7k)Shu&pN*~TZ~NJfBH-X7@p`lb1NDlbP!&iVY&jNPmrpSn0$56dS9MD}Ov)bQtF-*dEPVNIISFa|7E!Ul zGN2>?SU`FngdZWjPxG$-Vb;BH^nI$ciGuM#I+pD@<}CB`^KJZcq$RYz0BS&)4=sK| zngiRTrmeku{GPI+qGDJIWk(K#878mJm>twj6X_Tncld>`x#1yvWv!NXUL@;ZzkJjl z#T;iqA)COF@w!TW(Rt&9U#k(&Sdf zg9?A|&%S+|Ig)SK9@{Rv7JbcI#X)eyjj_C>BheN#IH*=s6~ax@Bc<%IU78;+k>2awxeTV6oIXRuY6qjnohl0Vyk6 z#4Spt;#Ni}>j@9OCgE@~IXO8|nt`hjIvPRfFP6pHzkcB#>%BR_@A2#2=MO`Suy9-y zEzaUeUS7k|UrC^|7$?>f*W6d#H#{d`=f+|`ELLYbFNpkW)&H>ta}JogScmFhk87O4 zcgmk0_|@EOjAbCNyUL)Bh;+B{E0K3W)k)+g2G|fn z`On$eNN7WW%M>sP;MC728pyjN6Y5Yp0`%j%{Z3AfB(-+^ww!(ZGzq^#`>ZwF_(>Tv z>Awh%LcXn6D6{Blv~3yRLCT)JaG9B8<_=y9=q-}iqQU$CCDN)CA+x4AR2Uh_OT&8< zCE$Xi;(EAV7!@tPvFACB@^AyZRNTS5V=PwREe@drmdOHdXoFx z<&ZdPnh*omD@@+7++UT6>xru(y)H(2-I?)7%T*~ferG%y|8+7qy!QnW@_?D29ISS1 z-kbDVQFZXMe+?w$W#M@eT{?y?{YcoJ_gx9ymOQNgPhXT#R7h2YdkVd$BR@eRx&whv zK6L=)7GI>Gch=1D$;Whwqa`$KAq|E3x|4iYZSq}nts2OKksd&((IG%Jj0Wvsuny^o z7H>7FT9X#-CR(&+hpnCCVI*Y1LK5?Z(e^G1br_wig-6uSFrt5aDb1QRH}ZOP4}Lq- zN16^6?r#0~@2}xldQOP_ZLM_zwM9w}z@4jfNOuzHi=(PSW?&umC`2KwNTMf>{G_Z2 z=*9^I=0sjbv?!cd^5(UOnp*An_hKt!EdRcFnh7jDPtndwlXg}sP#YhB-Yj;dI2mUC z(|UmPn+n=j=kWizZ*C$bH_3~jNnV725b~4Mp*0ecCnM~DBx&TL3dJL&qeng?&gxB# zp8sAFp~|*tz0EaqKx@|KqB;+2gPt>#^qje@PJiD4AwGG2m>K!de8gDo__P--|BEcN zoma_+hWtz}1ZM8P?`=T^G7GLnbQev$Z%C>YX&=dtAkh~W@wby)gRPePy*&>tLH@}! zuSUpJJvP$Rb{Y(A{d&?dm6%wU`_Vl#iXYoN-WlA{92AEt@X6^YXGJc!13O-3qkDRAv~3zB=g zk0Qt1pu_&sSSNkanSt|s#P_bhF(*PRtQz7}lcG{>OlIB|FJJu!yn#C*L2e^9LEYUE z!pkL4sp=rDxMSNER*%(b6wr1$kA0Hp`VYW0%)1?2T5Fc``|@p8?ZIpGHTGxFQgCqm zy!R5t%#fx8)@hH$=mv8$91~=>Z?-^2_757t>;4&q%FIndB+;a-c{^m z+9OpfD?!zSt0TFeARPxPHf6`f8SkHaEJ+5cqsuSPpDANCbKmJ8GQgn3LT0P>2u3|u z!H%Q8t6I*CIku*$B%G`RxKRk34;1A&OR{}_lFdXXC7O|KARO7iymFK3=4nIrX6&3e z3WpdOFA0`yoaLizLrFG8Ho#4LBAxUI*-aF&LvKyk95$A0TFEgl$jC{yTe6*sk!=1d zzHi@UvfW-r7|;y}@h_`9IIoM}#!R*!BQ)+nVR)o%0BNkf2!%O^-Hs^33&?&D^grtk zk34--1=*huvcK!abcwvpWZXnRedP4NVKGx-6F;cYT8!2zg;9l(r%8IccZ(M8DL+Uc zT8(V}gTuR+EBPeTPDDcoTiLIwXU&o38VQeia9-&TWSgR?&ULFvQITAPHUiFzgaA>a z{C%)ZbZva38v^h?lY_ln+;%k!1c<(rEmL%xai0Dk~^gHNL=IR6bS zkej-=IVIB7!6VoT#VXRs;iRSg#}t1TnMJ)MAEpR25wW_!jZtRO0(6oVV5qCgd2_&A z@&L)sWcNy*S~rdI=0Uhhda#2&->litgJ!y*_56ip&EJGlbMpFH4`}kE<-cH0+Ir_S zs|K<+A&++zW8H9*v{GWEM`zu9R4UTyvsrCg8Tn$?&9h8e{a{)030($e(-`g0T?NU< z*ocxO zhxhwgex;Kiw~f8PDa#rB+l6)46N+?mmX4f7#b|7!mK^`DOquWV>j^h_Sh)lG<7{#& zx~k^aha~<^{t+3qPAYa$^)l+lZZ+xFD6r*0iqEuT6lD9^K?+fpn*S9&=>nu)5TsJd z4kV92)GDNt{LP}M(KI8e@~*9)zN=}s+ewmR&%Ss1`|@zC3Y5?sJ$e+|B_iOZDimP| zQUhe4rct&A6%?WB0LZPHmf$2BUndTd}yaPGw%C_9Y(J6xwOv`pCd zTjx(ZONnXXW4<@7PYV3UEuO4T)-KOl+$@R~te9iDxxb1LNJ%Z3oC^6CvRJM3(t3P@ zJp6e#Hz`P?LtU3I;BPSKUdGtd!9~pys?CEpY)LNM$cZuPbz~$e6!{9eIz;D2pg^NE z29zt1u1+8`t<~p1x+k%OIz+nPIuQEfHaXPiwLT!#u1&zvI!VaXNJ6GXV+wxq*@_}r zS{=4ZF@t2OWJ3cCAd^iCgqf6oH@cOCKM+qsfK8hqL(6B@e1H`NcPN9a;(T9z7@6A4 zBNE7fqaagyk|`Sg)?q#W^WV@AylJPj$WH&vodjJ7VaET4#}|uIMm2A%ZB)Vf*ZjFbQ7csWcR?D=3^x zr15`{cfh?h@d%{RFG7XG)+wmpnMzV|+vR!guXDTyJHq3A2Of8uMQ!@1j)f85MyT9a zhLWG}kktP=+LVGyizqa3u40g0=pteM$KB!Ga9LBXq? z_Z-wtj9wV$3;LB?O^qvI2v)_+V*^Fub*m2Z+&!(*VC!z0-U@Y=o7=A2n&>ecBjLc0 zipN&i@$SS4#N?tp)|YMV?I+P9Jo@AFsfnjW-4?OzHQ2B@P~gB@2$qQAr$yoXbNf6rh{}jIaV7+6JmQW}3AyR-;LYX#C7nhu7@) zzLL&W%S0m`HHjVf}gAQTG>hh&W1j` z5A1_|>;dU~`yEhkP!R`O1Umx9zgz`cgf7@%&`422ZL)Ay8KUOxB~UF?Tg4q)C~$?Y zs-XMH;d6iJ4cx#Kw7*q6;EU%3(mEH64snW=7J7VDw3$ce)Vf`Ik21xG?Q2kX)9;q= z;;p{h_th^7w3)oFNjIIR3b!KM;q;{KC7qs5xER#1!C$H>Mv$cdJ(S&GH)PQgKwLn2 zJ_y|7)z%j>zmMdKJ|^=M{*J^JQ5~q60U^=5qT&)tTtJQ1SCA18ow?7T4&^jB-iusg z&ITc2oFsd2L(38$uG`a z$y;~)QIP=T73}rG4!@wU!Tvk$44>|?MW<|G8K5_Vuz^l&o#h$M{P&ozJXj+{j=r&f zbF{qu`QA_ViNrCo62gnj@QZfYHY&l&c|o~ca!QIA=(HNy_iyG@ z?_b`xi4_8HRS|etRO?U(^-hwI+>X1!V_f_CBG>*Zds9xAcz{hgGEuG%nb@+>3^jB_ zDI8RleMn6;1~ruxiUqeWsBrCvTsE%q?X?{g9XT215?SSw54)MI--fMS=U)_w_-qw* zxjDv&fjT@OAZnNT|hYUoa-f?7nd;oHsZ6nhE zI~HN>fp25)%Rj((T8+VS=%HO3|FB%u;QA!(f4KO+%W_>H%Mph}iXkg^WeGI%>}oft zb#yQGD6vm#iJVvYMI5{>MU2!QPwSW{9klMBceYN=DGGhI))o8VA7W`J&01IF?6A4z zN^>r*914>~P?4E8El13R^@WAo>w)u#J-My|c@(Oc`h;=K#Gqo^Wm zE-<>_CD}Adzl#QvU!8e^UfslK4-{1R{Y}b}MIQVL-tA9Z02TRgG5O4|lFs}e8A}hn zRT0FJO??OPlo#FQhc}NmNx8eYX_|Wwe+ON|`XV{HA{ioK=-4KMrzOo|b9z4Lj)nh{ zuq59gLrVZusD461g*S*%e4Xp6+>C5m(2V`w4}L@O^^7-qH&oWS$)HILbWw6^ z|BsDA(FI%X!Aoh zLw)jkkmn#mdcqBVk2L?c+oY9#ZxCn2Z%Pcw2+doHVagcd4jZJ1myoW zGf&pp#S>CH*H{N+s?#VHD zLM365wsmseIcwd|xmY{J#3RIP&CaPIPuoJ$!a=!dUVrem$Krn^M+VP(EDo(Y$8ELnnY$P=>hNTZPJQMcXUO%X8K?CQn3{G!YyqJ0$QYM}NP`s?O>=l40%rV>>G7 zAs&KC^aotoufr_140j#o<|Aw8o6{~o43C5Gl{D=_ptT6a2DTz>`psh1;P3{1RnYyB zX3nX3=T9_(#(D&K4Ld(lL`MorAEAknha!cgg}KSP_G5@&1xvk0lMCDoL{B1+c(WN? zlcv3WlU|Xw;;+zdx<64DX^wv}s8C*Gm@>>q?3J#Ko`f+6l(t;c?Wwjtih`$1Zg_?T zL5Ycd?hap*K9)od-Y3BkT7+?fEbmI?-`x5|5A&!(=t$Hc^z9pbvWdZ@zg#Ph z|C8=PK)dj^dn|HQmyt3Jw?6h1mS?m${Q9bJTx)$I?Z;{u3%+I!Yg90WOmHqVLr7T%^<*`m4z}f*qwvnI zS+f&(I#%i|!>;SV%*b+B1ixKw%-Wc0VfK{R-QeS;U$*dm^q4&`JEh^H1VBIzh;&bbsA1 z<97d+SzF|To;LY2Zm9TyhLL}OT4qVMcp}TVwht<7S<*c?gZ~Ovn3LN3E`C>4ye!`31Ii;XBgo8k#5;*!)o`v=3{e)h!e=8 zs#;ns5b45~dxzQm`}gkOXHMUMEY{cYwk+xg9#D>O{P^*28qqGChk}geSJ5JJwn0wc z31a-r+j6IwyZYT`p#mXO`jo|e|3m3}dS08Q_CoMJiPX&xX=x@9>1)O&tKWCh%$pM9 z3_kwk3Dq6bpPoTciYdhrasNoMAcsO&Sp4>0xj#=;rS3jYQP$6e3*e@q@C8-z|BMd{ z3!{90jpE;eVEI_>Waf`bj}^5*aie3X0WLAd`F`_Q8%JBtr*-4!|MXXol%HQ%M58QRAcG5J;9y47H}K6!s`6{EsB6qU7-O;q}ujv zM*qsm%RyxXDxPob?yiGCy&gnDsGi(~<^)w&|KlJqsEyyG`2Bxb zcUYLg8y+sgvY1P)(NMRt%cqRuS4)ct8AR!-s6ZZVXlUq~G>DM$Qzz0@T0wIn3&b)S zVWAV&JD!|}iyK>86`%kGW$peMPiF#em!kIOMMVpE2mcB(|mdzmruFf-=P&m6THO}BTbZ{cCjlo@2H89ii83(*!_r8`dgq3Y$GJ%?!^m+iQtVc zaA5|_EMY_}>f%Br-B1PiO_yT>^%_N56!<}UILc$Sp99)&V|zRB>t~_%(_nk@0lMJm zX+tapc+IsgX#e%9&hE#ALO!=G#UNZjuMXO~Yf(WRj@U)mV!1k9i7bDQNM{Lj;#`7e zD|y{4XqHVx#AW#hv??w`58D+*#huV^?K=HTFD^UVuEd>IX7v=x;6Ps%G`?Cvdq@T} z2DuYI>J`Tbxc1WgYHI3TBqk*#^`f-%bYD4zKXj}QR)^0*RiD1*!7w91>w#}w%?`wg zTpOrszM-Q7&8mk{-7&PxLbyRmtb-f{#0|j>4L2YY^a{E;MY?QNi``J|=^>LSSr8MU zuN{<1%fV3fz3qwJKj!p7xu!PQ4SI%E@dW%7%+T~~HXjKUNm@c>sx?%S zXSgm~qweXcItjulXjdrI6`(-<)u?GaAG)TNp&%cs9|yv;EPA0^u@{8hJ0J*>Iws>9 zO)YTCsMSms{1G&@Gebicg(UQ{p+*s?%Cv@BT8f@UqJtK`z-|n6eyEP)o!_7?diHvbt>=HXEHcssyOn?mj>ns&6*W@~C8wm0=B~k}XHnKb`zXd=&=}l6 zMgR0GjN6#j+5(MFnep!*Z-<}+^h^a4#8<`?He;W1Cl?B#!Tc;dMyF4*ShO-E{c1sJ z<%Ys)C3$&yJw8ai4T0``Hn4wuW(jrzI%g`NRd(TR9o`IsFN58vU7GH9Sc!t_Sg3Fx zDZUv5lRBi-L{Aq?I{~Gakc@`KC z`|wK@BI&$liD~GM&7ZU?Q7_xizg6Rc$lve z7;+W`{?hmFg-$uQ;zckmulK=)Ds2q9Qo&Vc5i0#ON+SD@(ML|&Twy!4cb7n-K!Tb_CxiM68fkBD9x;~sh2YG7fi^{Z_~E@dC?d?HY6cE{RjFG z14vFrpccwwp_k{2>Y$9Z7K%l$T3KaKUX_z8vlv^2QZI`Hl~@btrGXFCc(n|y(k#Y( z#dPZ{Fx|I!98kxXVh|dU%JZSq47x;x(8o^@C!ozn(gym_fs);T$<%^LZ~w@fCyW{v z_M|rkxlHCmFF5=(DLHH4uXrqE2->2~K>_hWxRK-jY=76(bO8-}>XAzM~VRY%CUU1Lb)O9aoqnoOc@?Fj}KMy5lEY6pw~5^&7WO zo7~krC{VW{Gy2Hlm|Dw1nsDgQCl5Z(o2s%^59xP0EdIz#iUVmMlQ{xzr4QkVPp zt%F|;q95Sb4<7O6@atgYDzst?tCagWwf#XyLRMDD)2F)tUR8?Lx73ccsM7OxPv>-6 zys)!lDh_JS)=IKmUh0hC?vHDSjIpS(bcUfWLEM_}!=Yh}sSjLAURR0c8s-&YXU^SKm?dV(}Vl^~y|+|wN?D7x|FXBuwfR$5+e`ftrh@n?2W_Uq!!0Tqep!|*shXPK zANu4FCiFn#fNq*kjxkG6<-3m!at@+3EAwObjwdDj=r89Oee<>d{XGRKwqE}3+c+l7 zkAMzyx*&Uf;^m!cDrJgodGuO}#AGWc8ifwU?^5i0S#;%9IO~M9!mqLJ-aohe#!C3u z!NVFFfd;!x>5tsjRT97UNTBfPg*dN*ChAiLGjX!Tfi@R!c{O&w7QwKC)-ako5f`G| z2bC)oIp&4B1WyBKr}Mk;j$n11VT=80dOD;NsR*0t#DCZm)@FyQ4V z|9w~9Qat0q{xn`}c#I(}eX~^UK(FvU9UN129+UMCM$MK^SxNTFvFWM0cgvq~*$n<~ zn8nCbCiVBr6% zoU_k0B~V{pJ1`f=?&&C5r@C?bTfwJK4BJtIo;n4fPSM+E#lcWm(=y@KY57 zzjl;{0^yv@e`aadJe(Ko}JRuacjom%NlaVbZ&)=Db-tBZu2hj0~ z>+)>n;7#DuCD<%$07omys#VWJYEZ3~6z-$ii9`NYtm5jtrE!gpk7O^?w$AId>+n2# zJt6Vs`Gk#Q!MNVzsC{x>a$@bL>C?L>J6Z$>Z5@>>?TZ($5Oa?6j-@NG&`{(WiDuOG z*vpy~gbrpLXf?khc96fn??Wp6j$7xQFYK=t@_#_&#$BN8nwbAw{#~QjMnUTdQ}tcD za-l+_vp1EwDX}3xl_|5Y%Y|n}+~wYJ%hR`B-YoY?(WjTTDoheaUfksp@1L6TbO{PI z-q|H8bu&;C4pf_$;C6M+UG|SYg@%4)zpm7|HRDaGTG^?3% zJ(sQ2{;Kh1X9-d0TUegn-Z2%PRyt@k zF7yclBcp+4Gd7m>_{2=6c+S%b4Vu8MR+Vq78~H)TFK5$Kt%f}qlJkzMi+$)I zYX!>!*X0*CnIsf=55#?tl2wcgxttPxUj5}~?!cC5!LN@+j~99K{bWkWX6dlX>e9Ms zqc7+#`Ldv4_s-nDlbJlsvF}oBPlLTtGP_*LIM#gbd#0tO@AiKG^yJ?;-N%^l=WlL% zqcTC ztQOf&$Donj?a9t;)umsQ)IVq1QyzyE)_xPv^Pes$KG>xwH!tgdUo<8cZ)!B?%`bU| zimCc=#x&cgPm^^`Z{xkI?Yt9yRvL1UaK6bZ?%SSn>Qt`20 z+A`z&irw#x9r-Z4nw2>gKK-=GhYy|9|CwU?bgY5ZJv~xJU?KhR=8tbo@ZY9 zXK%TC&m1y13!g;nc^{#sQz=|cV;XQ!&Wf*#MZK>(FYJxPmmf2SFWffwudJt&zd3V% z_EHX}?W&0tkJ6qa_X6an^7pjFI-Tw2Q(9fqyCVAGL@oERgBkX1_xm!oshV6J9C5gn zo@%hw0_(l3R7w?A5aU*vnj!FT#*tz_Y+(AtV})5(dKn(3J);=O7+JIqq7 z93BfQGU>}^Z)Mqq^~+zi#d@o@w_cT1;qL9*a@j|78%<7chW5*4?^$JaiQfCiM|TU& zcxL%YO*<6&?I_!2P{UT>O?OLbOuLKqHd_K0+tDuF?>`PpecY{bSYq2RccLx0{2$G#_Vl7n-3Te$pb!v!u{ zYH;K3J$;mFQBp{hk#l(1`)P#xTFhQyp&Tk&X;&N<*ZF;m4P8=?d(tObQ@5SG>yz0g zyyb%o`m?P_saNu#%esy!tJdxUoGw-6ai=B9IC?6cSIndvL7&AUK9sLU{a+BD?Y zsQpv|+pdp0*iQyX48F(OY)c(gx>GRHrh7R~%va`DpqG;6ja?W`W(pb_e;Q0{Y3QRf za7~7Uki1_)YxAGu6bm_4qGoT>W6z^!i3TQ<0qk#2eDxc#H0 zj_)5H@cqR$*BAGoUE&tqtj6QyXCpiJ9#ylGd_pyrljeU13%mRJQ_ zXPyU&H#jCM!WUF~{3`|(`>o5TB=!bo_&M=z8DWy6!Ip-9eNw7%kUi+_Ct*d0(*abX zNfsyWYgxIl?KhY97xB%lDRnIT`u?J=$ewb8T|BnobTf}l?Xv0EbiMj%uHiBw9=$5F z#O_mf+OM*9%RfWGf>kNEv8=`2o%m*>!te(4nkFaT4|=4ktJK5-{qOKuBWpR?pFj6Z zJAU~1v2z64nEzFsouoI1dT9bsuti9C~2m3)BfySPS2=Bu0^w{9(79g2R^ zamv(-(JS;`*@O0TCjG|Zg@bY4q3LI$?;3D^wr|m1W0ahF?mA6q~9r{(~0Xf`ix$;ZklV z3JKh9iO=4nQ_GUYTu)0cYEJJmW^=n!yjYZOci6r?;jG%X>L9+q4xLEII9Z!;CS?cq z2vc>s)5WLfhP7VZ<7Rosw%g7j^Fc`LHuji^mT%t{1Ycg_b1pDV{AOk~_@H4gBOI9L93G3UOV|;u_5Ol{`O`};r+Sia-4=hp zT8FPmbkpC3clWySrl`$0rQ@)1yi-rohQXK5OjM;!8cgppE{QvfD~RpQ$Z5IPb@#ez z>q8#Tqh^t&Gda)ys=8t((tykM&F*-b{=0Ot{V_(4-a_JB!>%8nvqQGyuPKy`uP~bsUax!Jd#Gn@Ky5ClM3rXDlA#m|G3XPg@E)d@r$`Fq3<% z%D-;Gapl8<%9gvLFTchr-_fLc6?nR%uy$LS?Cm|PsTskhd>zLLPxp_G_AXS!UXQx> zwv(kVyVmu=$^Z21MTPubiv2$f^Zgv( zzdY*plH$pyj^mS8?_%9FesbQO79G4~Ytd5)vV16c zrCi9*c#txAjc)XdPTcOeF8(j;y`NdO?mhRqWa_MByx`SCd0S0gBkA)Ro+qbkO3mMS zUG4LuW?wo6>hpRFr^Q^WWoG5=E(U289opFqp_c9xGx?tYn+n4i9x6tL% z==o4DJ`Y{G@3KSwnJ;6gs!lN_=G6S88E$cwUsvOML!ZID=_2BlOrwk=>*GE4+KvHK z4A1=!?9Zl|-Y#xM>}xfWZkXnzXn%HvsipnWbxGOwJyc15r8?+U-W=WMD|>>DYs60D zj5E_1jjLnBL0Oe8*tmc=tY^BI=Vk1ptx4wJNqg*W!v$xDu$=2a17GLa+-IU zMq=z3Y!i7bU#KN;aNF+d@uS~$KuE-$;jn`krG)H{1LdmEs1C>j>QR~)Chpp|q>CFz70Z=i(G*dcTVcl^5*D=g&L6>+M&Qc$^)l}|b`KcU0B~#v z-1I%?q#ayt7d>fb$NMz~$AHU%l#{~a+VM5gldySuSrc12VmQW7RawBa+ER|MC?0tJ zw2jxj{|%d)d3IwDkwh9-%I2`T098Y)S<}9S zm76>yQ!$=h`Wh4Caf~sfA`$HL8sc`Ewc&OOq8(VNG=~;i3>{fX%l0j_R|IM7jIm|S zD%P~uGo&^^aYYf&v~{zly^E8ER!|%W5Rdebj7RZ#+-!LBRkp2IO!bym*xXY{ER|-X zuZHEt(;0`26LwKz+pJmeH)d9h3}wm*rJ2rwwFXf(x~Mw@6)8}6PSx;q?R zj&EbURY08`VtC6^2=%ahXbBx|L;FgHxZg0Qwg*>104HYA(G|oONaArD5 zZePpGRl^CTt9XYbRf%>|@f1tU5FBp_q@q|&UIL{(bb6~7z@e@P#<7SE39`}^q@;BjL=-Dfjz8_j zR~#a0ib)s`p&Az{R}t=b9KYqk6vv5MZj8sFxyntI%Zo8kQIx>3lZ28bEFLkE=F)O} zVK-y_>!?b#knSm>t8F|RD(VOqI4mAf&(O9GYQu3H<0I@Yp)9zCwqh@?ArMYfkaikK zCSsU)H)V9-uSk-tOps1{ag0UBkSbi2F4Czuc6o@+MRlaoK0L8P+MFt0qJgoUjTFU; zD5xyM1{PIS67@ADndXur+;JC$F)w4g!?;~3 z46w=PWqV->^O(TeWDSRIYsH%eaA@-zy6iff0tc^UQ5zpiLBb*)+(KY{9Ir1*$|}Z5 zImFtB<7USnfI16H*;q23sN;r6lKRdTJgIm8Z6J-QQEy71fn*nl#MIpFtV<96tYN%uCNRErCAF~~l|)CZBjR^hRuaXZ3Np!8Oo@LCMeDl=gdJi& zgK@P{*4oDQvU>iNIEZemlwdN>q)nSBuI|L+PqL|?o{fxWeX)yl45qdvS>Xu*9*TUe zlvi%0$Lr9Q_7V$^pbS5rbdplP!7A;Zu|+EJf5`09XV%%Nbc_ z6Y#q*!?)8Ihc&fz*lssPsWjdcB>hFaK0VIZ&^n6gCTaWVjJOE6dl)iu*oXT^FiWx; zoO*hCSi5#@-{TD%Hn4c{Vk#;s7%^f5*IaWATeoiIPk;Io0GC~M8Mobb8&_X_HDCMM z*O)hN9(Uh;HxEAeV7A_ZWW%z@AhZn*{}1f;Zn__TjDkZCrC`Pk{;##0jj;rm3?D*) zd)KQKIZ>OQ`P=c<6cU`Y^U=zk>1uE1_mBOKnu=;JJm(VTclGdER}WvPt)SMw>uE_Q zZRnY|4a@7I@X#8p-PG3aINKre=8jR;!ozEK8@f6=I#{}NDPzZuW!SJ`Jo@H8Xp6_V zwnw_t$2Ac zTh?#p6Q>6djqe}NWJnl?#TMzMf+6hh@f@esO z&W9etvMkEJ@CEFxJ;Yab;2m0se|$OJPdtW6Bq{s+7f7rRVQ&fJA5(^ZR4I=(chY62 z`C?rq!9D!Ee9(sGM(%m}euCvbN~?kZcwJu39e*yNwjIIANq=;+q7#V(k3RY+rKP2u ze){SCo^z589S^O<^13KHbrkJg2{tZm=YT`2=`6HZvaA)CWf7|%LQ`ZT&uxB=nImR0 zyl^Dnd2S`qc#0Y2MI1b?l4id}RY8CQYTgS@j^ps!($|=`avn1#&)^edC-SFPUZ5kA zX7b3RNUqt;=Fl@p2r)bB{j3>uk)PH8)3Qx>yf<5pae5UG{RX)9g9yig}4Cdg6oZVp}eDE>qczv~dJc$i3Q7nLp- z(YDQaqOZ`pX)&Wmf0kzdCn&i4LH<@z#wTyQlx45|gRXdri4_T~q+zM$;4u#6A&XV< zQjXZz$V&$f$5q@+>pNw1IeuccpX5{jpxr9PQ{$rK@IxqGy^yk?i(q97|JUX4j+LUW zqnr~xZIrI-q11$Vd&p>hdG{N9%3VfjZ4pyvR*-yYEhb{oYA2~kl`zEeu+a(A;t7yQ zhe+B9wg$H0Dz#XjsKM9MP37iMObK=1cM|v_Wvr!(=SSAz@&+mCvKhH)J#UYxqTN+U zvN^$s^j~n>0jy<3q$*v++@*9LX!yU^A7^W!#qc4ee0q8vH_rV&%bHekTJ>32+Y4CJ zwUCI%MZB$uqc->%a?d~^;Q zMm1jQQkAs(UD&A*rFM$(sUqUREkpt}Y>(Bkw6+0{KR|)ck1;MffDSA?cqnrf;lYgo zoPsD6b>X$$jOZ%l)QxMXizZo>h_R~3MM0{QLQ_k5Qw0f{@iZ?bSW!dUu+h9#S;*GH z5{i-zezTH<1wPZp#O5&LI;y~`BIXkAt6bQ%+q+5B`m>5pmm0t!SroR0na&Nj8lp+-y-aq6v4>7x?@b zw~LV15cAk1ykV--g_PSz;*>OzwBn>KL&^@|?ifm-#EbEOJDtXFe58BQxSdYQIy-1} zdq}yUr(^{s?iKjbK|GOKqIkg_#AAY#$Eq3DGlGI(Gq%+Xu>!_6y-I8K;cTlJM`uYT z@v=%RV<=48#Oyd2hZX)wc)S({utHrN?)(c+*%m^D)%3I0Q_$O|r#N9}xFT%Ql24WR{UaxbAI%!Rmq_>6n3TcZ9>LgqHWFYQL*wE#*eRR#uJ(7&XOl99=EUyL zXA&u#Sc-HgNn&019-R*$zNV9Ok4?JAhV<_142Q!wj?=et8?b-?Iz_ATi%XI8B%TikJ*{-wl30Xhwhe6Vm(RHwnIf zgo(^+B-t3=QOmk6(xC*6@g!ZT6mN&4gP(L4-e_Dv+HtUBXM*yW==9dq*ICvze|nofu1@y!Uk%i^X{Bt+!abW--PwtZZDsf|ZZ6rPC&w zbeK}!!Qt)>T$Y1Bx{do@-^kXk7|~>k#}{nmjfE>Q!0<>bBmVUwu|x{T7}h?wi1o|2 zVmU6-;WF$<6Y*FNX$Mv;S;CU04jc^eWSALm{1so^gN2*+`EL?w?!j_-F~%Yg4O89T zg=3)S?KO;lZ2`Vyf~wXQe)G~(G~&Zx5l(yP@wDQ&-E{hjc)0igMsDxMGH~$rO$=L^ z2E5pA2fN46W{NNvdRiPB*SAuZhJx-moox%*WQBIrmWne!d>n3*#N*hEk0lwEj1#lt zB(^rQ=zm|r-EHBE*HccAN_P-QF~YJ)ds>P3I>118w2JOz0gl%Lo(k-!hX8Jzc!I9> zC9Eh()9rIHB<65JOPWeMOl^2I#%0qyqzspL6e({UD{fH`^WiZ;R`d+#uUkVTn%1zs zHNw*?-(h{nW*p05P4{YgBJCutG$9xGx?>D;DzS{kBzp)AVKJ5V@MVsHn!Xa+bsV)j|;f{}FO`wj&^`l7mJy^!zODFJJHZJ2(X!)pi zm*B$%1`;kmDVGZuhK6t(XRKO5Ni0Un?IALJ9ImpFc(Cz#J#<=~Y)x#zCXM6vP?3n^ z7@N+3hwbGhwEIiJxbQ^kDT@?>WzkaT=eeDpwh+s)GI2KN{j_!gooFWg?H@-zxsDo6ekNEatthgU*OdCZ7n;DmSiz)U({3eON zAV#650}nRtq>XJG9OEWwC21}3GQwL2?sBNJiFrLllcgj=Lvb;Lwzb2Fb$Bs}0-UD9 zNhOBhb<)&zY^HYOJW9Kph>@n#)k7COqzO|HZ)053CW_k2N!tO|wbt;GyOpTNM`f~u z^EdvDX`wX~rXq}JZ>FxJ8)FQe9-GDVu+`(kYhcKhb`E`eA*HbxxIM%R3rKn#jO9>h z5|pLmSnepT{uZL{7@lYe-n17xT23rnL&EJ~IX0eXm;&R$@1&?`-$r@!dQv#Vd~qV? z4Fb_E7~{ib$0%_x!wN(({uqAOM24ou;7U{yNET9QEGmMnc>F^dy76hot$QASG=ke0 zz+fzc$K}Q{20NL;g~O1xEgal2kMdwMttD<=Nl)etDzIG+t)3pLJG|2@D*wcK!bH0|sTj6n zdCcUxb$F_(aF>-qyc@c=!jK8za~)i+IHw{j#5?=#N*xl#pbQiR^q8R z^(FNKo^!&T5DVclhP0icttUZ6!lo2R_w+y{OnPX=z!!agosL7gCyC4N!ETG;tKIcC zZaf~}alv5Jj~(6-1RS&Dm&x?IU%$>yzK)$}lw{);{9{J%m|YmNv0N6(%^^J11$fE^ zUV8@+iAPzsVKtLV8*sMvura(2$4N8Y3@4sU@m6Cu)9Okn4)&j(>b(04uH)>OjulHK zNjquc=@h|E8++?|+*P&2R&)@pgK%dTV-J~(W7~wg7Eu%&2hQCS60Pdwa1q_u^T%34w#ab9`iMXDNxFt)aV zh@EC@G|7aCL-6|Cbhk9&@%bq%D~DthI@ZIG@!!xHLi#$he<;uP9gX;|crGR^1V z?S)Hl54Z3Z?)dRo>MLb**=U?(lAae{BzWL~cx$TJ+8(7XoSyfaLRYgrB6g{db$!+)D{jp{j#fhJL$xZ{3*r z!-pNaGyVV)0u`IR4mU@!8IfKL%Jkrs&1DMo6U%-ENDe9r3=`UbeN1 zhIE2RS0`IsaW*z}Q`xkMk@ZEC6;8qFh!RY!!S;>@V9BQCtbS)H#tsvTHe>8CZLT;= ztwTu}L)u9YS-qV?UmQ=eo0wI~)|kzlf4oFtXajb4H-*kNTuw1zZzZd(0+L=YR@#up zM^~bZPG2FeREm|M3Tmtbw&TK;Xd&!)2zHiJ6m4g_vx)}KG_VX#+)J{jokT$~fj|Lv zG(5m-1q974G0r%GxXFa6=%{L9jE97Z)W_ zgJbHj3LIL4i|OnfPco5YsHYUKyO`RR9^AeNWu6#ooiq{4BJ3SWRdadrYzlq-|4~aGK{h(<9K`|y>1e&2uXK>l2nku-MSIp@68l1R?k?k%PRgK0)1S=81<13-NpooyGouoTVb9pO0ox{K% zpx#qL#3>|F;i0Z=18(DCOGO#OiqiP46j5)4z&a^HUt7?yAvv0>A z#j2AlIC9lngel-(wNp6RDW{=0h~Muf7Hwo(TL;a_kyKP}qP%be1)X8+E-#J2V&YX3 zNg5x)w2zVQp@e{TSC}4e9LG~Z(jCMX3)9fLiLTlS^c2Cmf`f?0Qy9OOs)`~uyOJy~ za}z0W)8pFC!E4r1vtb2}6=%V*7h^mgO44yi#Hgxp=nnX34i*r?qQ;-5KIC88NHH5lUfS@Nz)G>60Cy^TF z!Do_`1frxeRSV@Cz@OxdvJqcD;#Cb98W_;rW3Vj`5jbO8P9hfP+7_6qVtCOU&p2mVk zwmC;q6fM9c+<1I0f#P9+q%DKTiBX(NQW#r8*O+1+sj8$P z(!!x#MO3?cSQXe#b58}nw2O*Zj44qses3Y2RvZ5;v*|1^XI)h_rKXPJR5@TcsBJOF zCFbMzd+6{Lvz9Ngd0Z{Y?i5wAEfiTnyu~R-1TC819!(3Kl(sJ7@Qzh%nEGiPPZ3U} zjq>JZniCdrpF>k^ifLP+WKuJ>7lwC_z+T}d7=D$KfWy%jeUmrC6>ML#jw$6XK7ZhN zdj4@U>zcb*QWL=ml@s1p%_6^#W21*tg$KK^n^bFw%!q8Ft9u-8M?OJ!O_-K~B0On7 zRZ)im<52A?$FkG3IGgG8Zl`mEg&pjs)jOOML!aQlpqJR@H*s~miYu8Q>G*lpHwj;{ zpR-RomgRqcj%2)qA&uo6+*E|uWAj#9H)*$vj^Sx8{q|RP`|n_`$*XIeWari`c%4vN z3sX**MKF~n^z>Z3!-rG$nX_Qcv(UB%rUz*)8qS=SPHO!=zF1euE2~>s*%Zbz-No4I zqJFPAZ(Tb}w{~;#l%Y(l?Z3iE<2xO+HHI0PHdHtCe=e~pL}EiXW?VV`4?NerDa4i) z9n>CBM*W1{2b(9?KS?Yd8;!j^g5`GMYbYVUyp6(7)b4c3-pfnp^UAtcX?9KJ=+eo&z4@OQU}Ew} zUT*B+>CNpl_ayl2^t%4<$$77~w1KvG2ac1XI~JyJ)plZUzlwk4I9!tsXZ2l=(Pf9J z95$5HmPNEjpCZ0>6=h6f#flYlHFq${)KlOKVp%&z+e{*j6?pGQMoYAXxf|!QHMy0u z%vqRsN5q`8VZ-+Av@dy)j~vb!EG6C5MrVyhERkT|+ND^VEIu)LEM1`ytO&<2 zzyYHRSpL%UxIG>YIqfVwn_q**1&~e>E1ke2e|;Ul$Hmp(J&z5Y8))m^O1#TqTxufr z_6SZQg*`D!s%ax8yc%DfhYpH(CiprQh6{bi@Jh?uw7&5IvHE7F9eD~v-|3_^;3hQ{ z{yA?M>o;w|s!iaT`rdsVP8xX<)o*R0)DbvC33X+O>_!juMjTB$03j#*Am<(ssIAqIi#}rKBpzuEcu6ta|lj!W%cT zvM0hL>z*N!=%yv*=I~emBCQyg8)FQw{@)8!G`aYPJ(p7_9KYj_0zNl^@#UDU5z-Nx zwrxFxic@%eF3QRRm?XUVb{jskoyINgj7}#xe%>7XZ~I7|a5zqMIc3q8v1q5cZ3BjfgfFGaV1I8lZHYA-owpIryh@?owstF_w77j7o#1kcS$H$VOgXZCjs1G@i za7g1P)YCy%x(I(XPI-ZaCltZs>=h?4h@r{H7BWdUEMrKB2MBI5g;~v-KhkfEk7OPohzy?$e)B*w*anHVI z@3r>YYyZCM`~7`?y#e>7WH0aVPee_|1({#)D^EVmzq??}1iAeoloFX==lx;B(;GvS$+C{SF)C!ED= zjBvbn$8#{-!X^VcP0jY%AqTtffHL&znpXmps?W(HA#$g5pZ<_77Z|%U{H!EWIo)oB z+OByN-^aQV=a1-fja_5unF$YYNK$+pBY@#FX6Mpyw|d0Wy_*~j*E#Gu6q@s{r3f+m zeZ^PLri{Z|*kNFQSF>>{$*LuJcg%Eco7>)UXTxx=27Dw1u2?Xc#=JR;`0rlbCLel+ zzTx)y13o-|1G(N~WAqVSY4{+0oqj0T$tNH!@85dJ!YsJkA0s`)i!~N*jk502*B{dz zmlUTxgmaWArpN1S-<>0kCayLAW71!zF2(1&^DN`i+4Si(K*+W8NVssW=DB0 z!j`zva`L8Nx2;?|+-qJHN_Mc34QwwCfO7a^s*+=lTZ-X6)>R)gk zdr=X7M&f=`*Yr*W&R9rS#smKz)AUy|PUR}MrK+BfM+nG7;R^d7lj z#-5iLZ;7w<5Sd=}=O^dM(zIh;_=3mt$5&$ztmDJ;R?29q0_Q!UY46iJ7f<;M@lnf0 z3c-)#5BQ#a4-+iQdCm0X2naZ9IQ{HXsM~X3N~)s5`#{+^y!X^ib#;G2V+hvca|=EY zZ7776xTfSU`ac47K~NK#y_!d-Q=AAKMoWAMY|ac@3(MUP7M#x7=O?utUK+o|UatkG z-`f8c?A#D>88-7)`E_~#wfi#v#Ygz2?6I@9Mj%NNnK01F7XFOgg z7F(WJYciRzpKr2XEg?jt`8u;|j-$=Vi(J81?{CmiAZ;L-cUZq%(kUB8({r|FIgzm_ zVM(KkX-A^H#41TTwP^1U1S-+tq`6KYP^1ZN91#du5fhZh%MB1b6 zXNhN-#&`jbhl--xry*imYkcXj($T@QXHw$q4l22ZaEc?D@HCq+6ESW_vY`_qU$Yw^ z_KJDkXYM3T3}w6l!Qs@9AK%{N$@aLFs}<)MF~QJ~E{{36e8|)CQ%;(I$hS5a2iDjQ?XZAdW$2JnG(yC zlWxSwC+w&$wa`Fdw>Tqpeag5;8FxADdt3mAAXI(AvYlJ&u0v`S%2$mxGM8!m)GuDT&V5EEd$t@@Sk;)khp;1tK}et3%%Et+Ov? zbWFqFm?TI&pzL;-c4DMYK`73mDOx?H94`5Ic$bqjr{@}e|GebZvPj`ZhaYj!e8k1#-y!Gw_)6fy z8ly#rUL7${x^(h6uby4<=J6pn^Fv;_IN*hgbNZK0*vKz=g&)$(H=`3BkTa}Du%tBeyHi0oY3u4u*Z|hYfLA5ye9+`HiNYVaeU7GBH~8#>)do3 z+;#AhU$W~{UNm1KP)}*;3Hi7He_t}gE z{n?n8k1E!in_RA~k?Rqg`H-&`UuB0K*6ao~5ubJ>v(C$e_!ebvhrfC8J?_m;`O5Jp ztl13`?s9hP|42Rf3SA9D_2;~J`7ijro2OjgwRC>%4`FnjVaE`3$!v2>RK7^mM06%6 z6!t08I49{su_16i;b!`TXjoyC;>K~xQCXp}q@x~_n_p&sQUQTCw=_}+lv0Rq{O6pE zUt(P=d}^rEC9gD!OZQ{W)gjBe!}VOjdWTsr=2CW94)(~q>xgE=INxM_SrWMe#=8kd z9kM&QpdUQCAF;mY`R1_Vw$CX+J2Lqrh# z&L4gWcX5IF=plu>2JFD2Z?z!k{_j&11)qHK3Ab+DBJRe#`<|e&5&z&$MP(I_e)N5I z@4t+C;z(B~_Ekl&=Bn?rlVhIsq%QKGJ#e4PHwivq&ORsCa~3}M7qI>UVdr)9iNjX{ z1_E`x3y;9_^BJeh;+(_D1Mb(aGkkV{6eKUNQNDFX^JI=1Cq$ba-v6)vEAnDVeCIBQ zj~-B$Ikwvnz0iXntj=XEQ?um2KH;|cX$j*qFn0xIOiIIthDese+cWJ1F5&q-)76V4CA>m zoaW2+Q14h&7FX7|yyBzgDYNq)H?3xv4G23alZz!Y^9kQ5hRjaRufFr>{zmYEG>|B5}24nt#H>;@^@k{|?Rk9-o|@qrG6QuUOiKN0SH4=a%!#Q`(#m;KS1; zd8l~$!Y<3r5z|57v$0^<7}mX}^Z^$FBRS-EZ~ZQR{QZB>jg9 z^Knt3L!f9bDdrVv-Jx4(Y#Dg}WDbR+(G5q!axo~`dECLphPO`N=B|IUy`L^n8OI;J zcg*s0IdZ91{J|G?D4T}=d)VNzA9HW{gi-j2kMo@EM)PmOm`+s^3CnWwlz5)gyQmTC zh9}3zygil-1^jIvSTs4O`6Y{xqGHY6M^DfP5x@C6Z}RSUa=!S;qy1kZ%NfI_LIKO; zLypoT-uiK1?`A=orM!0W2x+D~ynUCkX!x|4a%Q^FwS49DV^Vj-VJ9Lh-XSeL-om55 z_{ZdRffcZJd_-^&C#j}W7xca7RF*VdN8Bkn@7D;IqJ`q_`H)5Li-_Q;Y{T4b5VBLe z_W0!%hy`hUO731ngiS%F$5bk_=y`O!FzYhO_M+ z-3odqB|@h}k;U7Bxy+fWHXmxNOU!Vaw|8FP*DqT8>Be>V#7CSo4N@lDKg-#iL@YZ) zo~(Cp4ET-1oS{A;(T_ zhb5V4u*ncr;k_2bA>6UXURTG5;$-H2*|1xP=Q2Clht}|5&x{ai(3bObf6^CSb&PM;7&*JOY z&KC2|B`!mx5gr=kf(y<^<(DdK2OJ8RIt2saY{4TiOJ-bfowe#Z{l<_dm(2SOk6g}c zPOw(bkhSBhr;f%N7V-&)!!MAm9a7gZ+uaKWy9=^(%<1qkv(7qYzDe3CFm_7rAH(u4 zS>IF4JRh$0(eaWUd%@V$WtcHma_ykv~*-eS{sVS(ciQTQ^hb z5rdkcgFGKlyNsl^jG6^!y)EXW4L(u{i_HaT1hZ;HWWGotCQMDk4SmkN0pO<%?aC2KB8;37^j=K_>#h(GVKqj;tnCe3woVia+}S|6J+u_w|@IS;fKQ={`KX8 z-}tD<=JF{sb&5Cl>2AHkul&}33`vg2!Fx?s6tBF(PKp9#M8lr3Hl;lggB?aP;cy#QFhVog!_@XOB|)pj`r^i=dp(%b&qW`l#KO2+N&jGFZKAe4ofAl@dx6X*pRzUGq29fxQzk4U|qm7JsuS*C}{P>LJTl*aR_=ij%e2jgRW}+ zLokkLJL6zcv0pYE&nkTJlZ=z|&l!`W{D_5ZnT`i_jjUUyP&&(H(cp@TC+eJ&YM-XE z$T}j)4S)as-zSMXm|%FiIAC_#ntTW;sf(Nk`zK7StZC(Sae%Tpr<_^#%H39~xX^s)9mX`I zHbxP%J;+F{AkG{1X9p~*cAUHm{Ldeq^6)I@bY5TmdvaOum!Dno{@Z&>Ft~oy$GUY|?Ek5Q(@fqo|!cU%X z){JO8bmxJW{g1dA4k_d*u`vW3(pOZ)5k5HLx+IA%Sf+}z(U|jYp9g#QkioIOJmoZz z)Vd_d1}`O9rLby%i$)mvGDDjJ5h4f{`3{LZ0r3I z6A%FtNqR@?%n#B+_z=54l^O5`;vFz)ex{c%#eFTAzd6 zF{!u2HpUTHs5N$%o~=22<>6z#^6|$AZ#W*0Stfl_*IF8D>3RD%Z!*tD*wA678ah~d zvY<%bXWcKj+4T5TbBCSyoKjDj1VfOTwAsSyl*_dpmf0qoi;8i%KxjjiK&=)1_!=*r z*JvycyN+C!+zSz@8nn(=9)@Ac4YALC{|PZMPuH#!NQu!1bIibY$!tbqOG-N@kJb@! zMcw=e?zv~$6y&5V>;M}JDzzY1iuF<<4QLy&*VKqOBN7R>+=4sm z7?Vh9-;sBA_S*X(J5=nd)0DLPwH4J3+)rJk`~cL)Ly zl4ziq+#8Uj3+`426w^Isc1UCl+E~u!DazNRvP7Cdw#=BWMQrt8WY;K`>-dX3>JX3= zh#-i{0oA0}Cizp*bce*IW)U5Ol4yOMU|$C^?zkKH%P$gDF&4*r;x!(XUn8=L?PAJ} zW*efryxn=ggJjAF!~5vo7S-06^H}j|dPtrMvY_dgITno%3BP3nFZznJ{wFL##nWq+ zCKMz^!{bU7imo+9+=WuH)n4pWzL?RWkQhTAVv$%MZgy-4taq$wF}tuxLQ`{5R~ zf-jao=081Lu(vR*l{un&&Sw986qbqG;qCBuS-4Gfo%5UZXS|NZ)eF9}o^UEXR#@t^ z%lBV-iHo&O5U|nP;2Yf=%w>nV3G9t`crO|7gL%QyA{#KwH@N%QfOnKyA$-Q2?jbT36it_6dY36(E<=hOY;fXYW;$h| z1dnyYtayxb6TWlsE&ln*go|XIlin+glN34?QysV-r&M~1(FL=pVwOx^#%-@Gn})`^erCV`9qw{NUEBlyWnNH1RFJsb-Iz6E5|Ap7a#?L+t+#d8{Y&Ov%LRz`QaCSmr^T2eu=p- ztPOKOlZKikIpEddJ{@xbKRea;7q0!1ar$fC>U>EEfv}QunWkxjc<*^yHN<7bR&w-P(9w`MviszteCGRWB8m-lpwK8x;vp8!JQXr+G_8u1+oDVdg+eI%w zp5mKlIWV3kZ%Di&1dzeCeFzTc9G{&`Sk?EYJSwn>#8^*rTEM15$kn;a3hc8QL5|t! z$rX@keh%aG>^K>>dk4)~fu1+SgBYBpC=_;oK-eh>0`g7I+Ioaru0YgPj?+*6{Cx8( zVBws3PDu#?A&|bjjx`Pb%uqjGFc7y9LU3*UKH44P8&BaE*!p=tCdE1D%>+m>f0Z=Q zd+>n}0>-yS2?Qw0l2DZdB?wi8(2_|{qBNwvCFd7M2s@>A(EaijJdSW)Ao~%<1uE&W zF8q{K@AHfkz+rR5IPCIS(=e`UA|Eh#F7pOY&5yf}8Ab}-+@SI~wF|6g>x|Mh4mhA# z7PyWd}<>>JOu)Nou zP?|nBvpuFka3Nws(XdDou!h^S$Na7JKK~bWjFo|%8zbI+8ZaSXEga^DIOphujG^cv zT+Px{I2Y3mIURe6D|66_O}BxsFIgzfh4kcDVi#jo#Ic-mL-dKA1P2F;LvE$Fd3ura z!DNB7hTnUAk8T=sv8?$w@1OAg;hfE3Ll8BoEf_41IVuz*QLx$kh(+=@IOs);ik$s_ z_h&?YgIYzL(`9L3;5}Xm{^XPIuxu>OYJ`GbB&i#Zl7i_6XLLef=ki@*pnKy5{B(-E zIHoxK5O-|@g2IK2>9int0|ACrhp1ezXs)4UM4!hfVUTgeXnhlLaE{GmTqgL$eVJkT zuaHHJwh^Dc@gnoelNAeUYslk>j;Wa@3WUe15`v<3=X94JP^Y_izrj{Lps#8kcP_AI zND!amyrn=Pq(=(d7GX6NUU!Lr?WAIKS&*F;Xsx+afs^btgfMh<&B@L^6doS}K_-ln z_vx4#>pgee9d<;G6o#zYB=5#Z;W+I_lxGbMl5W!_b$3xdWwdOldkNe56eWh#afipZ zU%;AcDAnibNb(!YZ}ZV`4Q-d`)Us^^YY0kx$y}VXZFbpFL!_AUe)cJOG@xf9I#rh- zJp0#QBFGNIvZBf|>SV;u(E=T(#6>|`ruJq2cusF^I zY&cDKzQ+2pPcobmQb(LCt{0k(22`EU#AAw4LeW2D>*W8%(>PG6xSelm)gbVy*Wj1WtK3I;b& z$WBICrmXo1>kH2-al!xCblI-E{LL!xU#|^$|7gr7yDxLxeVLcnDpdWDQ4{#k-{1~+ zkR0*D(HxatXXwC6$G3Jp6MaHQzeMZ;gL+OLhP>zl*FD5KB^zwF=hgik3tuc57mPJ+GhI=8QXm49O1W=4V)GnPd`89SoJ;m>c=+dSgBokH^t ze=od--H z?G+3=*LhS(zOc~jP7M3$&1TMJJ>tWgUtnM|{@_{{!VP+h zB{J(0bw+I7+vWPpuhEGs{%`N4T=v)awfDY-d}0{g@MN1Mjh$0=9W@_Q#e5sn0u;@{yf+$~NLo18Dkth79ypD7uI$}YVJSOr6(HZfD zd*4Jn{ET5UB##O%PG<}jHO@*xyvxJA8^n`KzWgxfteG;898boQlTL;Vl8zJz)e!p} zZKo_tgO4*JHK306SSz=v+y%ADs9C3S2_X(B=}@YmHe;0D#R!9_6J`K%K#jk-;jkm< z_`uDwM0ya~v)mkVHeP2Z1cVQGJ)rD#8BKpophGjv7>YR_kG6tT)^t%=EqJegNQOpv zh{daTU$M6QgraZQXcDxCTubJI5u1w+$PDWQ!^I`2n*?Sdv2b%-|Rw$9=QsKcCf*Cmq)mCy0hhltJ&pLJ_~ z_p~C`8&t9buHfGM5hLFag5}m{kGa=-k(bIL+HTRw))B6x2!W$AC+K^m$pwi%!?=k5 z>Pz=YItjnAEb+;Vw>S1!>OgAdTwB!m(804nhCqy=Q(Q9N81XoH12Yax$J=P>=%sTS z74f7~Gp~;5RgP}HM%~@vsFyJ7zCkHFM2+X#$q~xe2qnmMhf_PDCpH(Qdee7VDVzaa6JS-H!^^x2=^AlwXi>ABdjY+OpJ zK?1QscNRSCzJ>^z&8H33#V)WU==Qa!gk{|HsN9^`l&H0c<(n2cDp`siW$_XN(?`k@ zEj6WxP%>rUI><(l_?pG~CYyDI4=3CMN^pz$CE|emdn<(Ew&qk!- zg19hLL7-%h4fO^7-SCV}SMi$@!*}{IAM^@he}j?Oq!A5k)r>j}xZaFW-cm*d!_MoB z7KUrH8${6!y1Ny#W7zeQt znj&PJ+t;|&yiF`Wq?_I)?M9^48Rx|OF!~*q0N9$ z=F7t#uc?ZE<}GJsPFP>3n0WTICRxmxILQxmkF(i6*WHKQO=sMS?h>utVQCH#D&g2p z5!1hkoNE^g%-?!9MW+G^%5fOGD-ImBN9WP*FfIN9gGNwfo3oVN9M z8apAp(q$$qCaNO(;yNyYC`s@kFge~|U1s3P{0V-=Y5!GT7OrT=!j+cB+txDO2Xa@_ z*aiet#^Gk?NVi0o65mV^!5{*}zQlXarBFBlr+GtJ7B~U5Eq{t}GQK_EP!8G6cBz7= z(lv8qxt%YGtwmVF#kWzsZlud;_DT(7AHaBeCyp7N$ zO<`!<1XHezKyW9uxTrCoB*112%MFj_R9&N-q&JU{zG@i{ zp>UTKSyLl}LJCb$&JcjqhOMSY@bJ#jF;(r@DJR?*B-pdoc;euqU@M7OvnSP%1?p zX(p37ow7jqg0j0ou>==I1R-haKs=8DfinqFUK4_c0R3ss(vAQas5vIt$0rIQG%-D5 z+deRHZO9(K11=!Z9IfA`^eK6_Lt-Us`4mUZq_<8HX@*Te`+ydKVK8_Exl9T58O`ux zLKMhshbr{3Nb1nXqwvZhg#+2p=rx=g5`d%7<6(ab57aUcB^i;kAOe?b>v$1g@XRvB+k+g5AnV*CAh36m&4aM+F0kk@hzNmX!8lFH1wk-PS?`W1!m5V7=>Z}HPI_CM_clnXhTY2vku`KoP9iOJk}{*f z1&Ic>pWI^hCoD4K&;+Xd$8tFODPKZMw^%)*X&q$O27aIZr6+otU@G8RziHs*i zp+Q-Xw+a;`s#lX&DU13POvT)sGtV?Gv5cK(OSY2mFfebyGd4wl$GKiV) zM%YnJGF);L?^5_a%=@g(D};0uy_m@`L4-hJ9c!g#y3q8B2H_>kxKHH;%e=$)#BHWg zK&U`KvQ!!oEZP}l$WXpv(b=L2U8L0Xe2*vy2Gy&)Xm-(}K}yAS*`bqe6B84K0m?~? zO{t|MYL>*pG3)IirDP@^(5)Vm72jhaJE7A)AJQtWb{IYz%dOI^0H)~>&Ot3 zh$T_tSiiSH=lV7qu0aoWD7yl!1VO|3>4fQ`Lxu<8mu<>>J=_|x4W>Z)?*=?RAzk!qyRe8YC(Ld!f z3~0=hoy{Xs-K856s_ij0Nf<2_eCgdEbFK4~NW~PqL>xO}>9M+lttw6%OF7Qbh-qU zGE^f>5KI;emPa2l&-bYp1-OKb&TY(DMvS8~79{S%|1`i%8RBcw*k2!tSbgL4Jeu1v3#=0+m07(RRL9wFX=+Ty1TGDz0P2CJd! zp8Rw$^9$a737md`+Vb*(^CzGE+~b1xRPVo!olL0nCDwUrYjM`%ng-)4ysL?%Ks$r7 zmS8Q$d;H}Ep)7DAkS}Y_4i+?~mCC(iE_u={0LV?retpJaSs4%JO~k`hBXK9ZEc(At~)jc4cZX72dg4&PJOzGg}mhm7LIy72f+cA18Q{ z-2|T1oN^Xd8J>y`%c5w*=)IfmN2b9xKf}H6b09L>?%;hOSWk0VVS`~Ba`I@7(2}Mo zD9%oB#$bb^k}*aooVWPP&&b~Yr_A1ei>L3s&C~bZW^sAGx(17>EY6spI9~{#Gji|& z7r_S{@qswSM;_}eQJmljEYD9N1WYhkXK@~^scBZ@T$TqE#iO=M&vKl+$5=-oAcCN_ z2Cu}`x&842um)UP#LlPdC@cy`Q8bRg!^D)YK|U0!55a-*IviS z3?~|-wQN=u@d`LTS)5^lC2AyNmk<%aw-TxIX@M(hOj%JC6`~5noj$_D*4-BnIBacc zsuEKfJf2FHSnG*=A6$nlx$5alvfC)u+C8v@X{hLhD>If!`TwN=j&s^tV$`1m5XIz*tCK;K;BLibW^kS zN%B9kPL{uL?@a$Gzg)vMTrfP2Wn1k zDl|DEXq4!1(i?CYrzj^_sxiLoqI}Jyw@o0hT~uh_)}LBeF}Y0f2s)-BNshP}FF{DO z>yigW>DLKJOkCik#_0qVTdaz(Qt@QtCQTIMF*q!>@C4X@%Vi_yC=}n9p;g@3;)eBVlOC-k9aZ60}5g+ic_-Ove ze6ai}O+Y8A$vE7dMYdHcs*Jf;c+o zRkcq?mFzXg#Mz9s?3|81=Jx3WI%iWpe9hyY(a_=wCoGFK4= zM=C8|r%12amoowugP~C+gZPrmd#{nl8Yw&%>nV%Q0%T1VBr3!>DHt{}krfDGsI)@{ zSjwnXPCH8w4T6ArC*ksgAqs_v0t$yZoncQ-IIq{4mLrUUJ>Sq*ibW(@HhoT;0Ugzl zi5|9e*g9jP*U9f{vN*?C!3X{|LXojIpCP5k^lGXUE{AcOtJDP6Piyu*h!IbR6c-yD zom}Iivk?!bx7jHqMXV^aAddyhB*BL{+Ez#rk;I05ahD%^menV%Z;ovdZC}FvGol#Zus{4cuKS6ZH4A<@xN0vl- zmZmK#KI`-mk!CB7=vMC$yk|#uxZTNkvGYYdlGHq<aG*7r}VcS zywoSelCEesp3|Pg8$+|dAXv|>EFrP&#*2(^@N&}T>27WQ0lPc@8Cnlk@mqy4^Q#zP zCu`qpM{3L`FMfesM7SU!819VMvDp9>eQ*`K{B>!+1Wvy|?c?u#n+MODBKa&o%36RPJ3eO37)H+h}N{=bHK@a%u2rHy(3>t zm{b$y#guv9@4Z3JbnKiKK{<115ivWs@$-g7SCP$glO}S zJ_m9tYnYUR%SzB#hxHbzBc#??+u)tW1OwJ1a*M5V%Ay6hC#V0C_}TRVvv}uul7r9y2?< zKptOmY5UZA2zYdTfv79uRUZ$EbG&nm772^9bMnICox{4o@iZrYc#bVCdF4q|2NlHt z#JwJIstC09@^xvjG?b#mILpB75xYJC=q*?F=W#;)>tCW)4ZTIh`a6n)qYGYl7yO1j zB~pSwV35x^mxjwuN#p|qn_@04i^+`O3!1Rt-L(tqI#5=QbOzOAg0SFA$+h_lbc++Z z)ft(8h}GxhJ%fl!(#kTN$KWL$F+ey;fyW2I^mtBDCb;0(7&zj2$-!d4le4t7-#>4N z=ay?zPZd0#z!x5VM8M%v#YcBF@4dQ1k+p7@K?sg+jnP82fuAvSoF@r$v{>?5b`R%E zMDREaUOsnTEPYK^XapKWvQWhg`OLdh#RCyMB^Jg zf@U`5P?UVHJLla_L$s9ueF7PWqaE@nFf4P5&amA;@RoUZ0|@Mtbqkyb#BrBgw#?OL zJp<>M^-HSQ;e_Jc-k=N{SQ3h;#u20afPp^5Nl&8(Oon?z#^FSPp`;c85EO;kW+nrNodHL^KC?JR5Oe*aqA?3>6fsM?%(D)n@vJW9aF4h>kX_F#Qu<8 zafFo>-sDJEwrscvc$H(j4_hX0(&4nfhDUP$@|3S!o>A%qX$+&wBkByQ!H9|9qznRY zTIO@)CF|umJ#$9p3O4zGDpNp!g{NCvARtAG41%r2dCNL1FM0jxhji79pUkaoo?*7}ianfWQbrFJwrs2slJyz|FCuT@QWT z&H=9lMUxO3KuCo4SXm-#gGW)NeF~}Yk>{l_;com9j=;I?;Cx^^oe`-()YMc}%EXUA zD!g?(JbQ^Vc9B7FZE*=f(j}mSqv&SH0MZB4yy2Cj5s9%Bos^4oL8Bzf_vl%H76GRO zWh^i{#rc|~sYska^d!o3*(@`>F0sL2)H#pShoIWImNgNZO^uZr6#|L!M43mRNS)?u z+R*h&g7Cb#sOblblY)+io974b78B30i9!fLqPk3?O=?lG)S3xH zmdgrjb8;JTs$;51aN#}2OUql+DHa%5LE;@=dbD@^{{1_wt!hY$(Jp%Qn@9n*5PYZe ztGFPkfJFoc1fG(xv$wq#@g-tG(ZhFwNjq<~rDSXf8iAF~xlWd4%G9%3CtqTl9=*D0?1RRC`I z_c3anrGu}my@(KkN%M$I91y8bDMLfmXkJWT;vm(ybihDmxc)W5?sYDTrq{u%OiNl#~hBJ0PLpPf;Da7p#alY#XD- z@fIOiluVH_#=G)4;{*&dM~uZg&ByCIT=Yi}JW(Rq>b#8at|P^g>GaQkDn$E5ZodRh zzd+5@EnxV0!0D zXRdUv4Uo5VU`wrXlWZGE54Tz%^?Bw5+JOC;o0|=uVmWEQEx^2-P(~|ODF~`%(fXN( zfN!1yr@XM3E7O5MT{jftm_;U;4>YVk6D#0U)efA+ctOpTSy#ln>($o!&FnHlf zNJ-6@*tYRYujVNg78|YkHNSBRWK0 zPzetRu0>1MdzxX_a$~G$F58z()d=SE2ETeHdq`?4*f~Gt=IJpaNqBNQhDHNpE;g=_ z_eLxRYb=uvaie@p#tO9VO!OH|G+BtjP9byR#tCA)jf{@HR zeY}ulreI(^+O0&daThOJ06j1T(itFdHmqr+pb9}{ifhC3zIPbT+s&5>gl39zFk|(2n5;CM4NPM!^;;x;MVL%4E=;j4}y?j16F$?=TRgOBzG z-!G}H!nuT<3Kz}`uJEe>vgbNVh1Do z-MiF-0n47`w676DpyfK&HKg9*wP4l_1ku)oN=!}W6iu&B-^9dDV0DG{6*9_ML=_8J z(~*X5aO_kC9zpCKsduOWtSi`!44G*7ThkMMYj)174O}N-%Wv?NWrrP^vwm^O?qtUG za>A{k&`FBYb0*;uJzl5Z?;~W!g&Z;K+@{)miB23b6!6-zpz9rt0+k3tC*`zoe7`9< z2@Y99qBXlV=WqCmmu}yr_xdZu*RP>pe1SB20T=x$b@tobV4EEzLn*i>8a8yzPS^3b zcdqdd-n`BmqcKCRxLKAAv_qyTxpVZj;`hGsb?&_QGGE>v5T_aQ&KNhAbhO}W+g~J# zM)+0TMG?1a*PE-&<98PY|Ly6555tS}dN1+D_OEh#=hx9m#IXAb5V-%w>-7H9-^5%? ziTa9r*^qnp?(t&m3EpziKiM2kM;frz400^fBoxp zBF9|c!ghD4OwL;LKXK=!3pTEAqO`;=+f5#OlB4XLm%0h}dwp)F?Rqa|g4TUPut=36 zRfh8w)-Lg@IL&Iq@9+U%@)z8pz_0hv!<6l<47KwW*4BR;YhR($xzAsx_DkUO3)I{S z*p%}*<)6e|#ELTlOntdOiuGo1I} z9Km~h0I@!XjWs$qu5H~7wF#QW1{_p`vd0^5|>#`3-SkNLs$9SGqkYA!Wb#cTzY zb60M4QI@q%gQ`IaM{gqVt4DUl>v4YkF((J_;hdo(q8zSKl zA+SDEq#+~nib^;Hf-Svddn6ck9lmL>i)Y1Z17}Bz=T4QeLLgc?n&RX6j3#s#dGlvXk|=K1~AHIhKAGK5Sp+C!w# zKA?hU+DUk@vx(6$Nw7?-7g$s`@m^5K)e|ZdTcShofoUnDpAhV4KSmWKdU(Q>hf4c!a_eIg2u$AUrY(T*Ng~ZF!Pe5K97rMp%S^ zEGY7{hgA_#fQ?ll>^f3dV$Oy=f`o2euycMv<{Uu_kb$UKl2!X?vA_uj2#oGiYZws8Zj_`uZP9G-~sj=+NPH3Wv5CV17kQ#$PAa#O}YW2JZinzh3_Wxa{DPzdIMg&1A z1O4QL^M04(^%NJSC@Bas;bCVBL7-dB(9SS60V@QRvWUo%xQsIN88#`gYt;bC6>Q8N zVnxk6J43t{NOQ?3`UIEeobQY%WQS$h!vu>8jt~Wq0p;3!SEOJfHAZRT5QwS*7cARV z%y@E4#~AKSrhI8JLp6b!Ff@t8NYCTWEtD9rk)N|!zK14IB)WAlbO9r4cBtq?5dlH! zD()|zu;v#uK_Kc1=^a|Y&{hZ^$dy9-8i%J;282VnhEZ6s?o$Q}hnIpX*<{pgAccUS zV8vVp3l@bCmafvcumJBMNW6e4U5dEVZX8*G!XadX^MWeMP_Dqqn*Gj@PqJ4Kks%I- zO@GdYZP9u2{wsHr9<>8ZW_m%RY58=36h~$qaR|1@se(nGcJ~F>H-}EQpX5kSojNO zQNn06BDWy$_`w}+Y;3bJOc^W1jmmJXDT#$c_Y$s;2h=3YL%=pAsR@j;low>fjbIs% z$LM~SXm1ZX33w3dB}Su{_+l;CXkb$)_QIT-amkl9hrB-MuyLcuAWIlV8A3JO4NJ1L zEg|vdphK2*xc$X9`TAGi;QHE_o@|KHm@oEY)`wqe=SuyP!0BcZu^C605ICqB5-Iu5 zuHEME-24)oo4-e=yGEoJY>t0O?*BD=Z!D1GA!@0SXQ$lQz0PJ>;+m2pk>JvdPNZ2= zH6zzb?WMfk{uGj6J=Q3!8lePi#qD!lFy~%;i`XiLnc;dTA(cJmRgV*Akv68xG>k?J z^e%Th5vg7h-&&);_XdOE4x`;`+`fBWR zpI@>bX|8oQF{VvLh?5P35QN}b#!1Aj^D1ENoDe*kY17`$rh_yQJw)8c+SAw_gIMUy%09P8^_^Pr3ZwkC>g;9DVPDpE}mf48g{@dHYa5 zBQu<9gE0UR0(o)VCjJB1B}`99Doby^!1!?GkIER(XHNGmSox#}_kcGzJ3q#a+ zA{Xckr^x+7#KT8~;2AG9Yjw(CsWA0(>++&1aN;>y39fz)9!$k)aY=3) z&Wjn%=ZqGtu{7oqPlIt&Smik5xE6wYU;R2_ZM6Ejz^th>(U{FXJnIh$Cg(4=e;A(52>m%s$xdD^w?Tb zE&{bPi10b!^lYqcgRKpMHbAY4C8a8;L|`Tz^NZ&NXs!2L)Tb=Pgkycs<~e;1I33i` z=oDo=|10~Lox(7-1BCHR^Hn`2S0c(eTXKg~b{NMMW^s;OEwIH!$+3=TRKh%t325?Z z`;stCP2^H^h)HVA!c~Z%iG0FPWOxLL>)`|VWsVI{iiC^&oXGV_dbdeB>tv##cTf{l zjHV_w7wBLi6nrpyi`#iZ-zJDkQ#S=ZIJ`I9ab3j97C#OV>k70sq;bXK^sJr81mb+j zGPJ>2&*%8i26f5{GMf+wNhMlN#58l{GlP#sjt|cZSX>+}uO4Qzm2mU)37x7WPc&z@ zZZZ_mtNO&nIv!7pvIN4!ZIB2^96}iM>U-)ur?df9cbwo@k%t7;5P~Px9YUP8axtZl zcw!Nlb$aA+Op&FCMpK$i5P@zs;V4@@+d;DzrR`j@mU{V2rV*%o7twl>V3oiKSf6=B zka*FA5b&hRGmR}5**Qz?nP-Q1uka#JNW-6R z-(i`xw9Y7Bwq_7O9cv5`c@`t^Y|YPz>YUU#f|B%YL;qxkt}LlJA*ccYG`dftBx`wv zM-Vl0BHIuIhyZKLC5eYJowl1GQA1)H2%!ytWV^|P3m6GjNrI3J>-LT~t#D*`0Yi1p zG+Ho?&S+Fj23V!}WMdmIB>mz7hE42$XPW4IN=9y&zsL5CN1F z^qO|9I2m-1qC|Vuf)5c8!O#~AV%1?ZT_S>HY}QD9iWHuJ#H$p9M_5NeMj+7D30gTa zXK_K|wLl2ZW!A?@L2#nYhl`;`W0h*{zGHzDisNXH&*C+L5J)HZqC2J=0$E%UTSEvn zRtO5e$&?Xw)Is9eF6Zrj3lbG1*P0nYc&u_nA*J#PS5AoBbssA0oMOWD1B_5|nIntO@u~ffQte>i{Sv z*}XT!x(L-Rxu;9USwcrCUhj9V)?3+$xTfZGs*(iwt?S>sQad~cPVM_v2*Ec;EmOS} zNBnR1)_J*`t;W8`-u1uLo_i2u-JH0i2~n45s_|z>_@W^VORTLp7a2{b$56nIdw{~z z=xuQA_dn~iC=5nzA%$RLwT$FpPH+`3aE(~TtS3Fz<&eguoQMWdda6VbB0*$Q`l4Y| zI7lU1Ne8#;m(-Fi)2`J&_I+mE-y|FVE(nP+6TGW%RdqF1&2g)OilQ-fa|%Ebx3SPO z#z}~lJr4w|ozXNGZF#3;NJK(xD}?vBprE%&hVLENup%7@Q>Un*m;4#hf2d`?D?GChPcdA9*v|tgBHx16) z*0{g~ny`|T1!#=BswL%vht;^S+HG@jWJUR75sfe=fNT4)<)Q{TZ?LOgd+MJBF2-T}s1p4}MdDx7QW;k|A9wn}GdrF+l5#WlF5t??8B zlud)cAYIFXmGkE^QR4z;HQrXVb1HleI5oaCMVD5v6?Y&6x~`8lfyykYeSv5eC}UA{ z@gdM1SVX-l395IGC=9tT4W+XU6ptw5{331RM8NG z#Y)98pP+~tHW}6Cb>g7Na)+8aprl*3T5Uz(tT>|4?L5g$9|D*asN8a6v;ZL;!bfBw zUfm@q&o8dVLFYAYmE<3Z3eyGT3MU&>D9Fe9}vPK5O@UDvcx>g=Zh>oC9jGN*4AKT zK*|W23=!UOkIopJnGeGO65`>^%RRrUiivovWEEC2eVb5KoDI}N0 zK`R%P4jT!OeG(%Pet-y)o+&6hDMkn^4xehEj|dWhX`dY}NR`7liEs|^#6Spbp5y5- z1|?A5p@MJop1dX1Ia+~kN(QB7*o+7YhN2`8BUKC{psE_Yq(P!(#*J*rTGQZ^Y}b+y zn5SK=5(L{mK_>QCq4C1wRluZzNF-<}adE&S={m`}Er=0xbV)1(ky&D8U@k@+s+SQe zV&pDKylR(hry(eY-XcVaQw~I+^3YsbXXbDb(-K6BIF1GF7g;-;?14-oQH8GvwP{Oa)PtR}6-r=hkj}Wz`Yb0K3WH!f`fD{UWBvvu8 zP!v*Om7?pG^drN~%#+ESlhpFvtr{2JBMAnhB0jA>sgv}8ER7JcLM8&d0^wM<4M7N| zi2x-z_mY7X+|B36y4_S--yE^EwZ*}~0rFYyaU==OuiR+`VU_zDsF6XSR7%|4xLOBy z?hV;^$q@~5#y$8iu5I$ayS725o`<|n7ntS=uSQG$4?8y)rR!Ip{rgfqfS0-{|K*J> z{?Xn#Ytc_u^4Y!h>s-G4f8zZ1|DN@of545K|7$wQAEFwKnVw-zkBM*?SFs2QRi}^i zma%z&1oGrHT-9z6$kpa3xuMZpNMI~$0*WG7Y`CCDhd zrd}~laT{-i;E*x_p%6p_-(c*Vx^7FUB)9(n`}*I-Z`{On2H5@$SbyPp-uGX__DkUO z3(~GY4N&EID?y_z77Oq%-#+9Y|LG&1H0-Z!axxf^o92q4zV{`pqu@iEv$gt~s$RCt!0H9$>ypG>65Dg!D#yu%fG`0IJVEn_n94euy2KgNGFX09 z1XT*~23xlew^tgqqT|Urs~o50e{j4{ms7s8c$XiYe~N3|RbI~$D4w|p5-4j!@3SXt zz54-7CK%^eN!0C5%d`Ia&sA3Ptjr(6vpP=pinRi0n&et^2LZH~beay<8Q$+6QK$*AlT;$bdXMX*BuTsL zAG?z1WS?fW3oa6`c+N zN;GAtK?ss~4dE>@0iiV!ZYBM5r~qXdI7SgkTvhJ-S*0z((c@IBDA;kZ9i;V&qt)kPPECIb526@)AWrX^&b!bOBXput78H zCZHY8Ojw_vkk|$%V#KqxQVD96VwFM$M_fCE6lf(eN?{~0E~&p>!JsAtM;`ZDPR|(< z2QAM7gS<6nQ6aEC&+%CdLeS_X2u~AB64M}pq=*DQfI<+w#z~1lGAJzs&mxjUA;I{R zT6xyw8OJ?K-<8B(aqc%Ew7@cH7R1gH+knSn1qc-(rNzq#x7sQ3w07Ge2$J#$Ap#e@ z5e*7!p%W^C9U(%%gsRPL5}sK%!mr}QP&;sN(rcfAepP|@9QtY)8tIBuO2%(9hHDvM}%m^WrNz`R4dS0IrAgtDCnW&%m{XnZLcK@eZ|2ih#MJKzY=^kr0-^9rXQ`eXW z-zPXjLxj^2i=;zj&ghB;q5D+PE&MZ<>)EDM;V^m=B?Qu4ki=^sz^UW*bCzsY;v718=Mc!3PW(unG6Dm)q>!hr*4|oxJ^i`@yKW4ylJlL3bl+= zcrNktp3Bk_1Q?}QmgVPwlcSi|t)xx1LBOnODc)t1<5tP-1gOg9N&*)M)K`pCplk|) zUjZlWp(#*UB%ZpM>%rE4Wy?RC1JV4Os7xM!B*I(}}Hmu9ORr~feH zG^rLKVCf26(^_r=EQ6qO%~c=rszK#BA_T;8+2%L_0fBXnXM)ENJRv+cU zm4Ic|S>>gzLjC|vT@kOOFi{hz%IES%8^YC#%gL5;@}<4H_9|3YgTcdl|`f|Lw~0ucnx3Y;mi;#n;)OXGYi-wBeks;3-8g*9hrW3E%e42ZD2GeMzKBB(^oL7l9x_HWGqD28nYuK?Djn zYOjq6MoEx@ZapVEmA5_Z{1WCWPh~QStU5XDGh4gI8 z3pVwKWWFY|f)DhIq$X!=c8(ApdFI6kI3$4aL1wjxJ(VP)`hf|7K zwoUC7T~{OAfXF$@c2*(@6lp}6N~8!#7s#8K#cJbbuyWyiYFl=AU3Q7m6p!VsJi~g8 ziwv19h&+7xqDIM>Acx=+3L1tsr%Yn-4axzu8(qpb2oZ>sCx|gFirf5LZ^^vC2u&j( z@1+RQ&dne^L0E$9x4@rvzSJy8ZNY{-!zh6eG3m;z#5XlEI3x|VPjPXCB_gciZ4p{2 zWfN(f*Ej{l4j)=&gw=s25yV6&DNx$rR=`e)23^KfR_#@8mhV?1jxLB6>#cWh42*tiB&OHBv=jM|HIy&_F9u=_np{p z?Y$%74ENq=esZeJ8dzjeq$rW1EVU>ZZ5f8qh7F?)xY2-L`UCh|`9%YMZ=m4`P($rO zwkC=eRTRm}%BsrDXTHNZ5wZ7P%P-cBIOk?%Qff6|R0$bGvNE6N-gDyY6R~6c*MC@{ z5U7l?L)ei>En*vfbT<$U#x5hlhzw*L#0557 z%8prt90P-9Qpt2EmC8-nf<~eUJ@B*_L=!v2Cx#?(;GvbU+aQDR#IAwBn?CTzbq0gK z#h$Bf&(qyQ9zTA}lV^{)yu9?8g0G#~S63yshn-P#C2b=XCZa^T{xRW<9m+YgD9yIp zlk#ObZf^e-$K$84F?PEjpvQXe@4qV5`}aAPpInHPhwp#L++ULC348G;Ow)nd?U}9~ zp&|_Pm+WJJ-QNHSD{u-ewKyCyB|Id>0n@^Ma4SL#{|3m+lV2~`1wVRp#UoW7$~$Zq z34J8Qo|-eE%ax z4>JzeZQ~JVwWcyLO(UhWpn-Nw<4C9#4vOWB<`W2*=Oay+hbDu0Tnqa$-%(YmSy8Lx zvyM(KP)g-E1#+>~EwIbJ)tK9Q04ZLf9q$-tOpbv@LhtGiE(lP-PT|GD@kBAgP ze}`CI6C1&UM;5TKpE^%;Ooql8RM{LWQ@te?VU|jcF6^j!%RV0vB4W@L;iK`Et2z_4 zYn@Cbn$St4TH%mq-UUU>+EoBAU;G)>;Ftz4>?Z}Oq;vztrBY&m8ofGboN!5KSVB_{ z6Io9|3R8BOWj(wmy?IGRc=7NWjJX1u$k`I|yf!pk` zK)NFqU1J^^$T_CKoEDvaPqfO7R*qqZigyL0#m2f!?9)3seTs$|AyNVmU_KgZiO?9T zgTfmbn8oPA3vvw2qx0Gu5a!@>+*iOzr4ot{qukdKqjGB_5o0qvMkEjvh8i)16utN} zU=EcW6K2AL>5dWt&RGM5l}R?iSx|VJ*@eAm$r1223g$ zL+ZdMZ$9Vue(?oC1>N>8Qxiq1UuTiR6yRll#~5!ML=z|y2^vTh_TxweO1c2uaEQjX zJ5uEiLwKFP!>8L1i8b*2?dJ$Hsz|mdky3q-x3U7Klp&L zMmnwZ*3)U_h=aXA;MhkFLn4SFMR}R8$Pq5aBhg@%$miBktsqh%8Si$VQtloyOQfWU zjTSz9cf*Hcz|w}tHWJLQg^%XXxf?pfWYywZ_u+QY*lgdY#=$)?IB=Tjm_-=7 zoiM5PKd(a}S9W$eCmX4V5B2xAl7z8PK$d2*g>q z6e-q0FjA^0E~CqRq;$r{I**J_?#3PK9+AK>!XO8>p)iyq2g$tF=S1syFuexrsk(O- z+isb6nRor(hxvv~4ii!!1G}10%bq4E9kEQP1qxd<^jPe$FriYJ+CALGg7ydYn*tJ; z=fITz0TK*hBE^*kNQ2si#_CTSubIWP@Yq z+2leDfi4=4W8txNK7%our_~M-tRlle|8Qcc%AoKL<6VRS_#?UCH=q0ln{GqjM?wgE z=R59Kdim<5Gk#{6xXgVTC$#uyk}eSGNpX)1r*ihqn>U28VY3k=T;EI4o#)s5{Ad3a zs+o&tzeOGs?|yp2`SEp9y?@scm*;X-3|9{5?S5KWRF^4z zBV~35psajW6x3|>m(}pvTGyP3QZxh@eDQCW(srZAPb=Zk4i$>$z2WnO?V zau2u|N-d}V&RUy@Vqx^|GfuC@BX`w!o2M1J08!4jiUCQ1j3SyudnKe?hj$O}aw0BBemAY__jy zIwOLa%S$W)Miyh%fMl0F>F81)LZC(^=gM4-&C7qwjVix*`VmjYEx-BZ`+WE2eXgn! zY(Okf(nw85RMZPHnq<&m>;hGlVlb%?(*fyjiQShji>p0Jdx{8i8ZZ%(^z^mxC-WsQ zxuOsd=?Dx|1d)-)_A%S~Bg`O0rHD1APB@x-Qf7qDWW!CU-1K)`Xl9N9MA(n-C~`nF zVxcf@vcGr9#H{SOs5nt2j>$}N!)R3^&RW}RN zrKuEzDRyWK#9B#O(XPi*U{fnnD`Ofkao|%zqJ{y%80G^SaE4C|sU4z5s_wmGhz`W@ zeO!R97N%gl?K4xlC8ms;kS!8xz_M_0JfJA=wvV{!FSrfxW=LFzJqPw2?ICptBuhNL zcB6H*nWMaJJ3vR4L@!4qm>2sdX!~B0x}*Hj^qOeKo6F~nB@i-f)r;Vx91t^t3DYKW z7@~u&s=Tb1)DXBj9@=2ifg*|P@Y>~nn^)*%CD)#*Gpw8FOsNFAxWT%_`}qwI&E>6+ z^D7QrKr|EQfmrq!Ml4ff|CDs`KBXUgu3oJS2(xrdQP7x>Hm}T3(2>zLBr&$}4i(6o z$Zx#+1yH$-TTJ{rJaU8@h*}^h#DVSnz9&8=A*rV*qRO0vs*#}@DOA*4hOH@3JGj)| zgDC=lawt23MEVIXLuNx}GmRW4-`^vZtMLF9F>$uF+8q!`rdYki!5~Opq)(M#Q+0Xwg?(Y7Kss}Eg{)jifxZ{gIeM6p4O;-C4 z0#5$Fi)cS}9sT>?_vh7k!#p2hxZv>kDN*m}fXn^w(#4kgID1Wy9&dawb5T+@HVrrp z`ii^Z_mEDA>6&T!jN^C&_B?<71M;z>=tS5Y=!f8nkLu64F6`)=>@XLFgZq>oK5!Q6 z<4yDLN?^D99-;JxOEU!0$n$t z(d&+H8K-ZL|K7)asUGC1ML|~Y^ygN*7j>?69X?x6QavqYy@)~3d5J3k(YgXB0p>EU zbB2mFhmQH?{qA_@-D{i)D|2_+7v(Ss$HB432Kbynq@fYXWbQErZ>*EFl# z+DR*Ydv`$e3_P3zCoN4-NYlZe1E+eDRMyIr7v@IDxt`u%eQlQW9?KaR!l-AglCzEr z zJ^xL*>OR5mynTY?4v~bRNqh} zp~Qh@XQ;RgITDa!TwLGL&ojc7FD`fd)64Jif4ce|e%yVG=z*JE0IBTf%;h{H5{Q!=Ae**K9Pl%wfyM0x=mS7;}tR z6f6WTEzw1nmKHO{@PH_ZO)2zmKc*{z&0Mf@K<$p8BOlBav4}`V6r*yWE0s6kh`AAdw1KgMc8bLGqJ10))Q zl(tV4pt31X8FYgQq~v>L>93$xW>aUdQ7+|*o|%{3C6&OSBgsaJ1*Wj&LMuw7i|`v8 zVN)Y&@KQ4`=Ip*BRjfvC%f#n3vd;!7@STSno~ba+>g+YpH{cXP;G>T|0)e-0-|`nf z{)-ld1VwMTy?aF-Cjvb&T|np8{f~eAWB&M$|Cmw=S62`C=tGyHE$oMxadY#>0CedA zvgt83LRLzX%30A>)$`v;s@E8&b0X#9dw&Cha(DL*)yi=Bn0zrHHqnc)-~V;G_IuK5 zgt+YpyACzj94p(+2fi2OFAyp=eBeH$Iy28Ru;p7~q=#(Cyok*UhroFAuIt$2Exn9-$y zLpI*#K%O&awI%s*WG$3T&)5Uu=H0uMQm%=n!}t2?W<0KEVsrJvF!&#oT-SnGYsGGE zc@W-k8Qw8X<60o1_rYM!V*?jZQYA`bvCOFXKvs__u0UNVV0`XIUeg2ZIw`^ zm1#L|gFKhh-AN@9*Yw7p zaoZM#O2pMi8W4-ml%%Gpk(by210a&Af)gz@f{*FXIkcW(~VTKWD@KI8K3YmQT4 zqj05xSe2Ty`z;K%vrAfzolB~!X5NM^Sq5?onQE#wvR1Cgz{^?Cd15yo`S{fvhB{KM zArfF}-8rPv%_B)WF1g^natZ7RXL0X+9k9k?ZpwkEEgsj5kX_oksToltXd<+{ z)xB$C#ARhv=-H#8Lqmr(Nng-Hsx8k>JUl=Q<|a*36J`xubHmHqFPSmQum|z$J}2YR z+rPxrczyMZ+x-Ksj>>g^hY;~$yb+_4!+{z+9Wh#5=X3>xV^Bn^C%j4EPzOG}{UOKF zHOWeg@eP3*1@%Y>f*!HM1#iN~e3pKXDp!DbJaf8TE-efr2xw{po^v8;qBHlOWFjCG zQ4YZ)XNO{xR7n*G6^k>oCsC7XX*m~_LzpO-11G9SWQRZ`dGaGd7fxxClQe0X8R!8c zuB;J2jt+nnVd|Vs>1swq$Q$>Y?DGr=$9`d)U~a$Hmm}L8n-nji)eEguz0e+e55Vxh zhdE57YCOD~=`}E?-oqMDYJeI&hB|4%H1qh~J3hJb=<`?oo_{kuB$Z4s;q|^^I`Qz` zyEdmQfF=6*5wO9eCllzyM5W^x_Rc(FAVNpi?&~*P%>`o5k1sFyEO+elkxB0O*|V8# zu80MWL&x353wx{ZCSGC^*i8r2B6ILm!kTXRdH4mJ0As%5r_VlT-W}L!N1~EKLVJaj zfXGm`%tUTP`ELD*GsX6>MX)$~mZA~F7^e*-bSWMt90V=)-UIo zo8n%?hr3LS$`F*R>4q$kPMrxn$kEjqR2h=&TazhANFU zMwmKbiX)v)^cJ{{J+U<_ckKCSe1L@=7G^rlJ|8h0z%F6?`}Ed%gJ3Sa=mk<@a4HL- zQbVE279{ezFI?)4dxEkaU?ypb_^fnRgj*2kH9XnH0B3(2d#me_% zPbb10lph~P{`arn@+UX9{Ny(C`8;CU@i;3_(`&5$Ylix#yvqNSH-|sPG_Q;kz=t1x zNKBDj3U$haB*awM?J`)Pqo-u!-QhKV@zcNLAOGWj%x9l{2EfN3f6O2J!5^^OJ!yNC zD-aHczaY=AeJ?Xb7k^t(asy6lNJA1N{ri{5aRpANLg3N&{=k_^Ef9={?|;Iket`vH z(?3FFM;FBFf!TjAZaZY3s2Iao*>4?uM7?3iKcjZ<(RZF8C zOixkdzK#oUdWc9^o-TmP^i(Hm8%@*odo)5Wem(x{fBZQ&f6;OG_7rsW>u`JvoPI@) zg`L@5JpkaYcn5yAK$%Zoq1u=xtu9CDx($cyvYf-1Pd*=n>F%)3ToURUb&SFFyVs`z zIT~u!J5mBS)977U9MGxOHR(l5T>}G{My!ksVPqQ)_Ek%*7nI2mUI8W?f&?>Pd=Nrdz5w&h$>9a(Vj;1o-Uv_t;F8IUcy0_vB3_gytg?B{QBePHFYmiNULUjhF`=Oi{S0 zd&auudfsvpJ2uZ=1e4Amcr_z=ph`yxJt{tN%7QZ`&If`P4};L;??26vq!Is#j!Nh6 zBFfv&JDHoR%&`#E88Va7W*RMwlQG64X3Yl~11&cLO&wSwR>iE%s%qD(N(3wPnwi3c ziOc4e5z%wEY2R8Tr-+yj)HMgjJyBVbg|1U#ua|mP+f_ap=1z)Ewc)){+@$ubDe)#r4GDGYIDNhKI<7Nk%*}r>@ zg*I5i+(%_i+BGNWZK7(=vG4p&l?L2dn7;$>-;RVJyx2dci~|-AyxJW&4l|osP>W1w z9;e%MLAF3rqpuS;bZ+>M1#6<@U5Ff}J-LHU6N3tgg3w{nNHGxvVoikd6hU~~-Jx=c zS#qCV9YJ6S6;pw`TS5}Qe=2l3`Ce~{%Q;Y!U=%tNM2wqq&24^+2t3-(Bno{{uEslN ziSz`-jAJ+=O}1;nkPuweE(wc5XFk6O^B|n6ft@NT8d$}GVG(*w>}C1>B2@!3K8p(x zp2-Wp`Yo}$d&{T?e(>ss9XrH4f;=|hw3#!}j99j~aJg{U6sArYWhB{5PvC$v1B{h~e&3pPEAk*_5rtMc}^~>ec z=aikteQU@Z`oCn)4TQkM-G`J?NFv_oYxP;$cG%8qkj=3�_2lm?XlGe@a2Py7~tQ z9q^dPkDoB!W>WV69Wq1xoXrrZ^?)_TiTOa^*t2?UzVz)Q2*3OpyY3ND-QPLc=MJ1M zM#ej1eiz6$J$-+Qem_a|u8@!j(xc4_H4Gn+^E)UW3^DAtF7F;EtSa+Z&>{<8@N08? z3!HvM4lM;$BMbwnA6CDD8O+m}B+GpAy35jxu0Q!zbk6sEHscxFVv6YrSlqmOdtx%8 z&vjb#FSnC3RbozCtC@G8@CfwWydL3jgnKdDQ!~)x51{j42CXZon`0)%d8HbxOh{>- zq!7+ZJII7J5W*R!d0j8li7JAK!5i)a8^5 z+Zd`+YVoiKU^g|!DJ85XOpPx12-h*5r8}DN;;sQ|gPMKVqBEgJmAZcZ+OB_qejbS$ z(e}Nia*`d~4Lfc(k3fW=nadK_rhu4{tldY|Q@IrAtOtxD9+ztZeRl%-7(RO}b`CbX z2kzCG4^U6ixL}4T%uU9n7CpQ`6pBl?YQOQK$c!@H(#;2Q6ka}jMu{Ue`U7Zlb4lzb zEV^oT3WpYfuXL7Jf;q&**{}Bf-gd>=D4~Ip<+}53r4I;=V1Z*!&R`|wVg7UA*wV`& zhjgMMRWK5onslb5Hjl@<^|j4`F)?nU?@ycJX?fV(I+D0&L&PJM)ew|Wo7~fsG5OzX za29Z|BYl|(G#1dTF>RGtC#n=Y_&Xx)zATG>zydir8`#x~rsP93IWbOmn++Dg#8$?s z(~(V{-Ct#wXt{9kRjPlt-2mclJOBL7hIOj+#fSvv)Dg@a%7x&-v1Vd0f)sZ4nx|vn zlecf_#v?WDxZXTw?t7vsS2u5|p)J3GEHnP_l+s~t!<9o%iasL2fsU&Zz1=B#9-=a|o!5Q1GdI(Hc_FQB^ zI}bsL)oZ>&=I;0y5U%>nWzD2$^mQhh5X`^xW0={Q5ydmjph3_u z(NXBdWx_Fd9C=p*m!y?(s^<6eXirfh5BY))MXl%2+n@4>fA)XngWCgp-4LrYvJ#ZS z#BQ803m6@{`F+Hcn{DBCFpgoOt0TPz4$=`YO221Y0&|RrB{o)=`_H)TegUF%wxyd7 zY_%t9WK!jIK0xf*#2M6OdSHC{;4T09;SEI!J3V^vM2aipq*0+)QoP_%dcbwup(gZ} z>GhgIU=BMrW-H?qbR-rBAs4;ycOPHyUw-_Q-`sY*7ZN|%?HMGo(Ifw>^eO+F_x~nW z@weHfA25!Qsz*Y&&pdqRJ0I}$sj=<8bTHjTHW%Ncvw?lL_q=O_`?EpWn9s+O2lTXWl z>1_}OZDoKVAyDXZ7)a*`)HpRHFBQ#Uj2-Z>o1tgnN&}01v!W?*K$VM z*(uNi|DH~alQNgH=yIJ;g)Oo&PTP5OsY>rYpBxgo*2Yc=(dzmcPQYnloNNt%FpS(l zj;L_FIY|h`j4>~eT}b9EWll?6xPNEIE}}W1Cd6peAS;+QAggeQeqAIxzwW)DsjXl$ z2`uBZFk_e}f+hz5K%ckXC@|qqzV|zH)>t4b>`NjPbLK;heqo#%KvY;$@Jc8gV@D2w zlDZfm}0L;n`U(*!fg~xm+Q{2XVo6-oN+37Aho$qCPrzAic{w!0)iPyy-OlCuV1M) zrp*~Ah+0ugq*@3VV{|xTDbaO>-+cQ2;5YaG!ewr<2C%m@!5KHyFYMdmLGtj6V1XJy zL`k($`-BBwzy0j9tnM}*N?>A4sYifVC;B`A4&Vqv&`K)x9^(|vS(5XzX_vjpGNlM8 zC71&z#2YZC9+qP>+dA;s)4#>-!{6ri(eLn+r@u)wV|zHz<+4Wa2VA1IFm64CUJjtb zWIH4+4F!Yf#n*MXW1DY40@MB@=$b14w>EtqA7`th_7Rhav_CHI5Jp3<_{RkB{}s}3hy@8Sc#YjLnxqu zsXEgr0!f9gy0<6m;P+Y!WC+!W$$?X@J#*bb2>h_#BEbRmWp-v#tzZ$7&Xd6P>wK?AT4D{lHd~&J=XZ7`(`ScJV_l`GjqELEk?D_F$0nPdGo` zUH`X~{3TKXDLtgSe2j&TP>dun#6S#*&3?z_v9)4-A>-K}+^!;wwuzUPH zuCD$%U4MZf&Nu}jO+MyBBg7af4LI#aKbK+i0jbqsnZ$z!A0W~bW8%Ss2aLDg&=~hu zV1?_~{|Cn7&oS9H#_7(RJ3)wgL!A}&&-kXJ!zGTReny_(cpC0fdyEgivKDQrm7%9`DQX&gKe%-D9|do}_zo%)|va8BizU><^V3mpIR*cn^fu(ZE2f1EDg{&hms- zLde-bV1R#@RPRi3cRd}>R?R4}qi?A|Iv-m^HBcLC)_yn_PZ9$^XFX$_JgR(IG((Fg z9(81LKFvbHY?bO6v>0(~zozIt#_22^V*Ob^s-EKAG1l2on{fm)4qXESsbf}MC45O2 z#!0}0BB!X~n7?1w-rLU1^M3`jrlG$mM|NmYy1S6G+uFmYHBhP;E1uC-2i9FcCXSA6Jy%tjR@P@H&F%%2l>{=f0 zIc9>*JQ!yZ9k&lJ`HqjFd0fqr~MRc9)P+ec)X zz&d&x2vj=DSQxMfNt7tUlkO!uF;w@&`2&t=L)AMYqIHN1c zhuLmQ!K&ZOUCCS>22>(bf+)sDi!+wu4EQGQz>G0^5qnW*I#FVr$YG=sU14Cphi6Gl zW#pAccKrdx0hSna=0Qvss@}}Pfs?5+qb|c8ln^>L{YOOgXK|vSS|}38HZX)lCDKJj zrUQ-YBvX+n-f#^StZ-8&7cqyxaoO zbm<{s<0B)eN)Vx=DNe%I7v3x5RIa(c{%2^N==&#JUjB~nkJE{9((BoSAr`6LU%@z) zmq+Stb|A9v2%AJe*dEH6UBZv|{_uZ|JpC@0zyCkyz4!lfXKR{_wN_`8y1BLhR&n68 z@did$odMen?~~e|H-<-CK6t=;@4d(OzyEzwN|d=Wsgk!(NEEVu;Y^TRxde4SKs8by zNcEkMK-qmg<78%Z))=|^8KvHOqVQ6C9In3d^X-`;iLQId&_AV1S3G?9cYN*hTd08$ zHb@_M_}E|j?VGo2v-?}%^zHE2^8?xtR-7Jr!3$8$dC`@`RbWj7#fU+${rX*JBBXI3DhS zq;(x@<*tqtE!@m52N`NL%&gnXEE-;6Xi)#BRlpzrQ*g*cQL!vKCNcCmEsO zsWuC9rK)SxJR;6MEtm=iAT_%}(R1rs0c*xoPv3977Y|~1e_4bk)pctpg?U)Y+Xs;ATc0!uGQPL>+p~gR{X&i#JvPr zm+raqUJsu6wVq5UbETMYtj=7VGm&Z?Q;fXpn-4B@ytpu4>=ntzVc7B)AN>{p-+%Xt zPK?mrV*!oWiE--HC5^gb45N^N1lFV0&awqQpcM_t12v+vz9~<1hk#MNh;GI8EXm(l z18?G0ONui}Y#>8~qQ>s+3p5I!zW*ExLac>awj2=dHm7S_Vss$Td_3ojQy`G5dnW{_ zQK$kYhMBIxE+*zi|IqPbpLiFxR8eXgvFKj78hphn5H+s*O29CUjU*OIOS?0Jg9Wag zci@nmCFoTfc=6;sXK+2Z!UCi^BWkDy%z`scVvNbxMq^q*d9+Gj$Ht&J*zh3h1pom6 z07*naR5uFPj7jksQH^l|$f@_3=Y?^K=1E^MV8Lg=ZA-;sWRw95aNBRe9Ha!D+VyFk z%oxSf-S9a|B7%jPWVEYG7Yxa^xF>PyJm{i|5QBL9JQW&n(mE5uzR4|($FKgF@4x&v z{N7LgoF}i}c<@c|SYaQxtSonFXEQP0dSj#bT%=`Bsv!~^PdbLodpDU4fp_~0D#jx# z{NQGTSl})V{+eRsA+;3BK&r+u^c-VAL&pR4WJR$+tdS~}q#Lk~h?1D8xcoG#$DDU4 zSHl}R3%rdFnA4srnO?=EdIFm;Q?%on4HAtgF4qioa+Y~v@>7!s*T%fX3{|@wQ>=C&!3 zjYX2Uyt7*3Q8!S+GmOAycSZ7ydTQvHV&#@QZ*WwPm(es4(uPgAB)&7`cBY$;q#8+i z0|ZhOu8ODGPU7i^`>+Q!?vgT!vM)1zG`cvFWu}rCTG3xrv2H`HGk4Nq;m8z6mh95b z0E;}Zfl&P39b2q_F{4O^tsX#kD0y;NEb-m1ric5%-r1mf2sAz%a{KbBp93F0}>a0Pj2E`Vnp%1 z1sn)}-4Ua|u4(0U^Ed7HKVq}_2!LsRi6%i)K&w&SjM&tQ`M-j3nt$SBSo%*cx%i_G z+5P@AU)Ndh`Je&%%jZ1(&;NHk{~!DpYZEIrbwnwJZe^T+-uILuFb{z!ptqT>dqN-G zyO!e~L@_8JSzVg7shjBRnL-YK1~ z+R0m@YN#~OWl&#xLPKZ;f=Xr9iJ}vw6rSE(aWQWhZfBTk>qm!Qmg+51HLPiW+om2A zS(33#k-H3Yg?vPtY`~>3-dPK^wt`F1GI?Sf=AHVmyhAwi;{e0phIcje9uwxrm`CpF zkwY0d)DbXt+5HzP0g*&Pkup=KN}Ve6?d?4fRu@1AEmiN#<8&4kE~aO}6-Lfy!4Y5a zINf8MFsv5x0rCN7Bv;1Ceo3mgtUa_@4Zv=kyi3_Nb|iI7=HG__q0RO17j?t%eW_mi ze9}_<7T}Z%!@MKafvzUT>Er?#9XUq+`G;Tf&p-T7ZirWp;1SC5`LFsO#+JtbdoyPXLw{X;^Jdx#qA+}Mx>fabdR z%>-oScD+xre1DBio4cNuyA40x?$Dr=?&!^$=!JAJ2g`9yx^&=J#mEv+3sjBN2HrAo zATmqf7<+;msXA~f;e+(#u}oqDI1>MP6)!Q%>yQcUAT6CmkD>>cD?rJO#@CL5LLMi8;)Xh zVmxe&BjOIZ8Y;c+9b{4HnVDrkL`c>KK`U(fJNi`Vta3XH5TClNQa$2jLndqFHgp6j z1QFjCtdjJ^tk3--7sdfkEJ&>s+i}Z|V16%DS|opHS#{D;H8`jgAEtV&#@l`eVszE% zrXs#8Mii-uSR*MJIaVUVrgkKQPUd#6MWkjVb<8|Q2(-Zm)X<}1yz1|$qV4*H8Ztxw z0eyH#Di_4DlG?t4ZP=6!wDPEp9hqW>2waFa18-yDAj(CZ5Oqc;%S5qA-?GIu=> zW8zjSS&w8@e2$af2Z4@9_JGv(!%4g$gTX|BjS-|n`v+``GD{+g?~`{jaCLJ_>NZGg z%8@fc3d=N)vV;yvrq(;^d_{_TEOf*ojd6;Q94z$x1wn-CcmI@^ul{e;dZh0kI>;%$ z79j<+u`$UYwP)2gF-{^vmmX5FBJr2PIHvg})BFO85W*Je1F7%WZnvPu?eU#ATfgD^`&B)@ z1x~*r$1(sngut-B@an?A?3X=GwRP~t49@SLQcqP0Q0J4s$GgO>Kv(ZRhh_eg85(pg zitQK}vKN?!caK&Ut7c-83|YOyx-%e=XI38wa#oMg(~H^~Gz!*L#zQEFc8Po|tUS`mt#N0qxI)7tk?&f>_SMS3ou z$4=*I_@w}_ADwX;lP8_csVA$g34GD&%D@QX;RWr5s&P+>najz4RZFEST`R6(Dz$aQ zmyWkl9ILr^uD#AtdQ6+9JV33+R$bf`1&(n-f*afGTv(DAPp%HAA#mG0Mn%|8M@oo3 zXGOdaH!Zx~KLp^z7eAwC!s7B74N*7GW5&?Fv!Q0Fl`1})$i%qOX?;)2!5gT}TUA3k zUFl}bLyuUczs*>1iJ`MoMhSvwL`Au?eQS^yIYnym7u?>yL923m@x&kErpUq&6UZiP z`VmbPNgZNgZFWS9C(01PG!x9fPnFn;LG!s$?Y1<0Aa4zUk}k*=Q3AOiL5;aPu@?r7 z+4lc)*`c^1Zh1ZPFFT6RW6Y@oF*e!HMZ;;xsIx`JxO$vgD$|lGRkQznlj>>kqQvl7 zT3zvdO-0(?k`W@8+9Z4;h&qrjp)pPxs6j|l=<3248L1YwwV*Ll2$a}!JzO>!=qX(^ zRC6}A4fAze>fk{8Yog5v*;zF_gkzuGlQ?z}T573)2NI|v<^y%fGZuFULafsoFJCu% z`X;R`%^T(CvrIgL&L&dyd1u8^yI%~G1Sn56@z--?pRc$YCjx=HuIE+)7k0zGje0nw ze%(oP-%(>kB@nA|9d^tpy%?9vRnVk^RVqn#E)yfut1_l7F-3xE1D-+@j7;N;bPGIhvJXIY%r8N3I9U`ynA;HAw4O&1{ zTuEVugpR7IB_R4UXj0+Tutyqzrn(Q!Bs5P>N2rkyA*V_}7;5K3q-AdVbpV@*Q5boG zAvlZ}n7d0}?yq?9;FfAGSM5ZoQt5^(bV%ggmU^*e|MVemuJ%}nJScm9Yu@p_95EI5 zg!KcLZJ6n8sLTS};$CDC$TGXPuu1W>RAh6(hQzJikr>w|7$I{dBj1Y?7uGYheq2>+ z4GNefBU_jK-i64n7*pto;?L?k>3Q(_B@zR>t1DCzR+PvH-Lg+FO}81fg62zN+&G|K^g|2(# z171U-?;d+&RbEjy$r-2DBer;)zCo%t|HM=2(tA5Xlll2)X!X>1e;?6XHXdqa zSQe?C11DSOMrAXmt>gMBMwPKOdkN z{rm-pa@YUhYZLVVY^sFNlXiQyyHD6`zr%j}yL8)U^xYGr2-D&88ShK=9E_E6L#-1p zUi{Z!%8)*E#;FSsgx%hUE#HpsSd=-xPRF;v=~v{?CKHnoh@Dfiv`cE7PLiymMr{u} z2?6GlfXTG3k_HU&G@rp3TL-dY=G~h{7o$t+zDL+eix$g;9 z*<9a&+!4fx=Abf%fLUaY($eQ#0#{P-um%zKcW=;YTwgw;wqcG^a|1bohaW4JJTg6* z7slQn52rYC1TBSF+`Fa{SytD9(*n|sW9Pq7V*?l6jMhpVGr8M3z+2f*SukXSuu8H* z4eBz+)@BX?I*h4H9&RvC-ldd4)Z)@KaSu)n9o~ia&zTyddSaX!%hjZMMnGhd>NV`9 zo+2d{*t3Kv1p4BhzmmEZ4sl|fVrj5LDp4z)8L0ufW7=>t>>F@e_Fb3IX>Cksbiij4 z=u{zSi{U<9uZprSOC-Acpq4TvhuH2BMa4a%HEa=tR7Zk&gkITPFtp}K4$BZ_BdD(O z+FmDOID%+%E&27YEy;1f_^2kT2!krS;syK{L*yYNLw0Z3u}{uc0eMK&kX(wW#;pt- zA`pbQC;mX_qEEs9QD+^eMQ!9N5&JB(;Jv9d#APe>8H%UCgnAvll{q3;sg;k)aW`|!aZvfaGb z_Fq?NNDR!q`{I&Xlg%!nAzy!_^kALcGz{-C4DYvpe}-1Wk@9J6!DlCjIs~ zF>VOeINY?cFlMV%FN8#lTSD}v+sjw~XXfbzA#S+b{4O9!7a<7S?au8TbwcHr8{5C? z$G5=gSLCRrv`%z0;LD;xGv@JJl4WRK5WY}n*IENuDJS5Bpyf2dd10Kac?`@N@WL6W zdRBBFw>Q+#3aoerxNr$tFd?)Ky{TfY!$h8_H8@LFn^wf|0#e~-Gccvd7_O)~^R|44 zoBAGA193W#su4?QjMGvu3q)CU`z250DL3qFKt+$!caN3X*9yVf9GT_F^_=ms=5cBuvigud5JctPaNb%f^5RQmJi_ajl^ zJa*@^lg2#XW3^IEIEpi8P5{)C%0y%ZVYOB++jsMFcZt=|((&9673&#rinGTN8|>db zTmO6!7FuI6_v0P!zaH5i4w%68_N2SM+jz&m&m-IE=(4NY5vzBhSC12hi@=0lvkyTG zUggzLI8JAs!yH}G*gj^BOOfhd*I~CMm@?cP`Q)=drkkeK4^>1kP0UH4`Y=@yD4m;n z#gy&g9cIRxhtJxmCiSj*TWf97C|_ep)~&w8(5|xuJgF99i&@8#8?wbiB6PjYjhl_L z1}dHfCt*fWq}FwC?AoDUC9%3n*Mb;TT(X8ba9!e=J%U>tIJNUnS}CD5dc+6}jiGE_ zt#*%eH9NboFitVLiV5Eb`g*#bU0PHSjchfe5- z?`V%{%gu0!m`7ndquLg&WVY2Gnm!RHlFU=ef~~u-ckiieThe4s5kpCfOtJwdm&>}F z?vN529oXo+ioK@PF*NX8LpVwGsBJx?^>Q$w8QHG4)Z+0VAk`tZ44} z+SQiY+MqeXLsg|#vO$ze6rnQ^Q7-B=hLF362A>Bc2)paTu|DN`v*FVRmt@)T&NfsM zvwB3nNt-(r0@hv7nM)0`6vnXOm;_BOp>yD5bkeag_4sfN^f92p2VnQwks8xmwD)T( zWJHt$A22g8$y0>D5PZG5;lOR2U0P{@EHix@UX68VNF-IFswakqNSt7!1RRWs^oT?~Avb&G85G_E-9QzHQ>^~-SJ)O8WSO7wkLx(M(BnuwQvUCUq=BUtl zIK*`+Y^pFzBrszZ=x<#n_}=$_h)PG1jxtx09T^%6v#3E--?UweK0%s~6gq`Nv?f@4&qb;i1@w&F z**2BX@heijT9io*i^6_*N(j9Jzu2J~ypDPGsSjV?JZH2=_Y#8deU7;z(qa8sxEBx5 zxHK({@pb`DXWrW;=U(J`ceg(V;OUe95urUFqzg!JWz}xjwa@y?_1Ulb@hx!r6*(6F zku<5)3Y;*e@jm0Eiw;Y~^|(tDSxb9*d(l+${cs4Ywie~mbp(`c@7$6BdZ_b zp0B6)yo;E9z^SIVnn1Ob)rTT>`n{#|UK@?21j>0Fx#{YMQr!I6)w5K(;7M%&^Q}iT zi-a?abX%J_JKa7z`_m0xOk26XkwH7RW@?|8^Q5-uVF;ybLs1vd>JqR;ZV0TND${W0 zaq_>L&g6k&cF%uRazR>5x|K>@BzFQu^VvsIs=4A`h@3JLTW9!8`(H~vNeaQ^x+^Pi zG6^U~PMxQuEqN5w=4EUD6+&B6|0j!)i-#kWa?UszsTH8XJkii)onDyL7^re$oIbhn z&-;3_!$<{TCXopvzu-p2eb1-A^%2@dHq$NdfA(Xx z#{*(U4sIeZArNX{&x{Sx*QhEsU!z)?!>Xs{%W9 zR;+}8N?aKyLD%cn&i?*ns4Tx zeK2SF#^N)7JjB90JP2=0fe_W$%CRw*f<~9*1ubMeOd{ayUNB={Z@I7|bDz*)lzxjP z2ZnL(F>}9QB=BQ<$}g_pL&ehz)fB8a6&iPR?OP~P$g&}$Xz#P#V)eqaqobp6P+=}c zw93V9OAupYi5UF8%i3cS2|>Xo)HeLI|1bDFc$(O@4?NnxL5G>6WROUTkt{P^_s%83 z1fVCWk{WO-A&_PvX(7#iZEw1#-fR(=#bu=zWop-k@jBg-IXYvkk;!IiN+j#}-qY_h zM3)JAgT;ezI%zUR7lbwYW@DV9LFWbZO_}NFm?a{p&%2rwt-||1{4KHtZc8K>T%?)( zwlz^&Q&a1k_BiPwMAC3l2gF@Rzez|Cx)cZueEjkMmXALCF9{(bu{B_8YxYKAo-6Z^ z5b-vm1^5a9bML6tz1}fhu-koq{qw$m=C%cKHmaO4Od_m)qvf!wTc+3-mfqOebqtE=Cq-#_h z-4}?!?ZsdBbtzxJXgc{Y=zENtU9Lmqr7FkkOo6^Z>d*MZYU@EMWp+0ZvP4XE1*yRZr_;x|H?b0nq9lfO-RZ zx2EiYKiEvqz)bA;`0>Bu_rCMraMiuSta>+=N>zCLy72txw{*7?R!=-uDV0bdW{)%1 z6jsEgIX9BYLBw(|M4WM2i*96{1qEJYtVO@1#%6dyZ-B)>XkLr?a0dngi zDtN60%^h{>(PFMBT%~&F;ShGuFj{MMw#gUtOvWduo~Q9CRpE;Fc))vYK7_1t!1?UE z*Yi+`CU2B#Y|9A2Q>mN@7|6c_oZ9P}XD-=NpBo&e#OH56;mz&yCdWGgr&wF(+zhLg z0|##P9g0tIho7diR=Pp2;zACw@+w>ta`l%p3`=D=D0qiWB4H=bTDzvy=izX!C=b6woq5IStWW zSQt@Ht}_uX!UH}^pU@E~$s^arLi0fw-9pB-Sy0Y6`K+Epy5P`l{o2sc!zau?cQ9p8 zp)39ZDv^Y;iG|pM1mFAor_~v^Hp?le)L@M_hg_YeO|}@g?fhH3%DI7kn1i3625&-y zHlIo0&%XtH;)urbGF>adF(3qt-01QG&9=tJR*h%u3 zYpdjno1r?T8JFlRIm3iAPLMo(ReV3sMd%xwfJID{9E>Ss0zyP6u`pOcr9FA1C*pd5VLg5{bQsbm{qtffvE6&R|svE((+u@ z^0Mt6F3nB*6L1RK#AcsBgsux%HA3iC_994A2rLCc63VR1LpU{xg4~-?`PCz5zt+0+ zU`=|1#yC~OBeYM)Q~u&(Q-+aMCCR=B(S`mr&; zs>ip$=~v{ajTKoKC(a6$awgR)RoCu=Aeib}IEkLZ3P7=Q)&rlTv?kq2U`Wma^zpcA zZv~$jv)sttRLm!ok4PC3sWvx$-CN@&HF*)MMpD_PU#h=9x1`Z|${aqM?&rV6>V zf&vFmXB$@0Q+R)uK71;fYMgb zE@~@qGD~Qa&#B0Ix0L8-kjf2WGkG&pbKkDvNKOl=aYm)KPPDYOkD;6xCu9wWP!mea zs_5%!XmAZMF%ityt(+AlBE=QCO$OGN3`h(75E21v1w+(AcgD0Xa>jrYlr;o`M24y) ztVvW;W1Jjj`FWicV>sgk@Tz|b(uVR{i`Z{_aT0AI7wX?nlcObR;8m=#LG8j9VO#va z=WbXBN7UFk2vYUJw*e=B2W4J&{@BtHa|kTE{3_LJ=O3hjf^bAxz;k1q+I1iVkVqEe za&%VcUEfpkhTe?12O(0`n-MvAsvf}9oLMPO9D=rDSlT{4ae;gG0>+k+Y&|pX!AUJy za$%ehAE;m=?Crpl`4wB8vDhqxS_rbFw3M9Li|ks7=qyYCY}y!e>ZxKoRzf!-DyZ_YS5aB>ip#r-PBO~lGf zMCb_oDIf3)dBAHfiI*Sq=U-fNGb^+8bV0c4X3`RTV1<%zFuiU|vvGj5Kgp`YHu2sM z9`NwlmIs&pJ(U4C!z9(8HE#X$eIsu=m+&u*pmP8Bmcy(v&tJ0HeupPd{!>rWTkfwo zfVSs`yk?H4qW-IidS=G_>4|OnDyRa!5jZW36F^yjQ#i$ur(#V}W6-XhvJ@SgMgHe| z-lnlNZvM4gn#}1bKY(@K-Ruiv^L01a0A1w$4KW z2LQpmTbXJ(uPWq^Zp7u3eBekvre1X-J3{Ya{k;CI# z`q?)s4MH$4%1e_iO5C9N^csRo;1=C(HCu1cucLvrF<7nw@NzI(r7te8n!1gDlCw>Z zTJOsizY^q7-3$f5oX;h9c2DBR;Y`z8>gjbvJdB|T!_7maNb?=E_iNwL65l;@_WsL< zQFWoF8lm|4cH-ZAvP6z9)jN5WY`uQ`J(l;=(>k^l&bh1~N#c^|=HD&V*HctM@S&=$ z*ja|$K0VItTI}jFn`B8;TMKOU>lj@C@A3xRJ5M3d=aE#D5(Br}jvN9d2IdqHGcFI; z-e5I30~I)SY8|-P<})cS8#Le$J1W6vrY-Mh6>WoY*Ckqbj|Du{rrqynG&zGA+ECq* z4In(415{@_ObyD+4>!qL{+3SED2rPM^?tEb`S<)RI1$) z1yG~+p}M?DS>DkD1|(GV@Xq71Bz~w=@%C6zdiH%Jgpt^o@~8dW1cXx`4R_?znM(PP0=p#SjVYu{@HTYm*`stq`$)|jfb z!t7qe62V$v*SsX%w)0pRr_I7Roqb+i{7pf)>Jnz{{gPsK#yEw9Jok#r{}&#Lm?!%ujyd&(XhfOZG^+PKP7C`K8Z!~+10mlK z54V((Puy6GM>mWTBS9+{H$P>V-uj}`Y@bU@sTvlMCW`w1}{Yp3E z?c28=Bw^M%l5HKV5-fW$FG5ZmxHnj~0nepjQp@`G3q!M}>YdMVYE=6A-^Y_j!&VTv zyiTRRyI^yCOn0|K&p{M#1@S0D|1Ql4xlqlBQt3?SErNKmoGw?5Ez!na z>@MJJ35RI8SXlEo`AUPu+k*}T+v<;$-Ga<|f{+dOEDv4w;RG>y`Xi~w^rKe*Uc>1c+g6;@) zT**{toLX_-Slgg!m71+my@fri+J+Dtr6nU<5=Bhe4t9u1XEEo`Al@&a9%+BwCA z$7+01W5R4{DhMGSo3m9~8z8o8!=->&a8?I+IE@rh-oz&irp!b8Esg%UBvDcVgPA~& z5`sskXL0|Tg~+bXYL6ohHOx81-kWH99XN73KW^1aO-$GssV`vH#+A!b7I0-@u zmC&N}HAFhi7`3Sxd{}kudMvu+uEWD$EG)iTpW|m3K}LF+opHes$%GX+`P!ypXcQ_F z(S$Pl_aq548PR-bvf$5-T01QDbV12>M{L;{F%}1~#hFgE_BxW7cV1xj+F{I%aSFtF zBAWZ=Hg!O&k|&>WrYTWc$LBV=XgO&nBQA3nVPeA_6;&85W1&OEn_b&JQaVo=HIa3O zVv?Q^)Wc;&p?Z^2f|9Gx-8poEm6_gzeT~dR4+i<^jv$GD`{g^vDiAhoJ3$zUEIyse zc=uC8CW5#TKoj&|VVwNtZ+FL60FcNsaM~~a1vsTXQZ}gp@^5BOj>k^{*la)Xx<`%U zzkJF3vs>n0+|pe?q`$pjc#{cpMIQON#a+7hI{DLE|K2{jaG%cC9sdrG6F|`gIGq?L zoxO(3!C)DTyEM4l`smT0`P;Tm=iv~`@LQsA86&zVQ5ME2UOI5P`~c}XVp?jHUtTja zTm49B_s~Cc|8)J?FeFkRkZK%nXU?O@zvEt-R6V6W{St6G`9}mFdb^f_^)#$8VrNW)7s<=4_O8@> z60}9D8uN%@=t?<&)bUg?a4L2Me|Y*MumQMx=0-q;5)zmYRO!m>g$4dF38r)IvA1_(s&&5Yfd3-hQ_Ids-3(IomwX*21NF*1Q-H zm((u-4L!cxF8^3l(w5g*qzdM1zkmlrd~Q@LzKD(OXs2N3jFWlSw@B+3i+UJ{!Q;EB zb&mZSTcW4iyQ0Mi!LK*b)Aj1C{1pmro(>pVdunjjU`e_x zA@cNk=J#JK-=Bq{99RYuoA|x6cx?azi3bhJ3DW*}*#~5mu=%y^k`_r$ zz;-+k@d)q+he^R&TA|<1Dq)FZ@c(sW?!P1cHw%+hhFt>=cq*K^JV!-1radZ^UCwN^ zg-BSS%MCci#yFjJ(3Rm@HrNmj)b)=%j-1wbXm=B(t>Ke#qz2&!AOf#FP!>Lp`Evg zd+mxCofIy@-0mlHABcEUqKXmg(zx<#vPK6;CVtPxCe^D!T-s>@wWZXCBRw8lZves5 zXiWs`-4hs!OFIiQ(I8KLorDBL=m=C4jqVH0njrSXpj6AwD2fr=pit3{pn+(eH&`Sw z4}Q*3dXP*(NZuMCVMx3Hjm)*8#fY^+=s5;sjBt#A`CgUV_o+dc!-ii__)A{#Lf=wj z-=unlU7wiZ1*?QpO1rMTIT9B*S$&QlLGh_oJH{kXW|F~`_I&=qd;I)+?~^WJI}A2jWF!D>#er{r}Kp0uO3UFj|HK&=5I{G{GdlKd$bGR zDAhY2e+saAo93V1P~J{R3Uohs!1QoK877b;>5!54cI^JfQ-&WrSYIQ}LjB6X+pjxh zndvmwd(4^Ic`EV(oLYcJt=QDmG|}2Pg%jhn%!yj0dW*;De2$Y=U4tPWq=?!HIH^_a z;g7H%{7>QGCrAn>#_4O;%(AZE!GouNljqO>Gaf$t!?o!ihDaKs2SnWDRjPN+IQ`OV zF8-!&d49HLWqW`5HAErb3=_XS{{MO`K9?mNVyT02jO63VI9H~HsqsR&E?yv^nXH{* z@EYq>90<0uOop@}pt^P?_3TnG@vgO1L$p$+k<$Cadp;gf8Mzqm7{ko%Sa^yTmvuZ1 zzoP|FEcZmHYYDtQ+?)EwOEaSx(xJ<ES1f8z@l&`J>_`UiU}yk zBlA3yYDE;@zI)5Vn86}rJ@7C8*+1vQfAnATuIu?TdymJf9?mFD=4NKhw>OLp49`TS z-GRZH!81?pHBnF7(?tdZ6oYqf-%-aSw%d@;z?cII1tPV9g_u3XN`e<3&JcEB#=G5L zW9qI*_J8M`)v4lzWmgqcTiL9bNt2UW>w-HI8P%_!MWVM1zttp78U<#`tc6V+h$d`H z<=}y73}>vU;T^@W6v?9eTnaz#mG94fCJ~>>6U?Q0;KO~vIQ0E`Z!Ew`8gN)Jg;<+| zGgowQD6~W%hn`C@ox2~=n)h}WwLTR5Nc`{xMEM6MHC7fCANMeXWiUo+6EW@e$bv;UGfJ;w4#~g)i*{q&~ z5(Ekz6!Z`U*S`#ngs)#ek>w30szSF91Y)9S0Rd>q-0D?6(Qy|Bo#m5IMUm(0h zTEM~rnis}t0V2EUfY=o)W7$Azpe!vUv=zLV&o^4You6m}PLoTR#}Gk1Yk<|W;;hM` z+fhZ?*33Xa%!3V5@#MK8kzh+W1ZeXminT>6MvRBECX3&<%K+xZhw0xKJRWa>3tp#3 zD1lAqGPVW#)jFWPN2qsN*=gn$Lqny?v8_cQQRuBg*AqnpgACeA?@!I5h7Ta2?j+wQV0y)o}+*;0=>^cZA@jd zfn*V-5<(=W(1y3VB+x@YqRUz(5yJ(_EeCNh+XY1=F$Uulyos z$LYPF9r)zLcTKUOd2!Z^i+arz2yI+yCLj8i9Erhv7kttGc>m`3dCdmyhM z$*L0hI;r03Z|Wm44P0FOsJ+L+I7Lz)33KImbIv$*zw}z`Yc7d;i}&wLs)wES_Ft#t z*YK48<2%gkjByfF7cqtxF!g)@?wn8l6!V0=7MAO>8garxuzM0U!R`e>nCer+3oVvnNE1`PKu%(k_KXBH;HZM4qzw7kGIC*Vz3crx1qc00^Dw)Mc00zOO zdR?6X1?jwdem0K>K#DTrlC~pot9PhXGI^EK#Tfa~kAAe8GyOv~Zh?`mZYKoBr0v;rIBD;}q_^E6v! zQozaMWS*FY8mah9CHD#d!A+c1gk%36RW7LP*X!W)9zv(J$tO>ru$=jkG&$oC&80zM zVZ4@D`BwC56RBrf3J-y8agBYiF3mZ66SP8X?Pycug&0SHS3ytLIqo~@+B}$&+}wQZ z6UROwR=K)+>(`(-$XXbub&iv^u6FC5R|`b-G&gMw4;Hu?-f`>>jOms&B}7;g(ro?S z0?`Z^?%ZS2C@G)KQYkTj`V5O>*f51iwXT_W{Vqt3l8F7OE9}>Wuj5IY)xK(38W7GF ztV3{>H5?)@j1vujEe|bGy6mzmM>DPIQhS$WMo%#l9Bk$&R1P@fWONH8Yerf5EnA$}ux5CNcqY{o6Ox+CgIiZ+PGPaM`}yg8X=i9VNtKG$&Vfl|sfLB^ ziOFXtiP5PKFAZ`g!3Bo8thX1UyYY@_33mrMDC+S>(t>t1gvLRJCf)RFJ&0eahOwR9 zFEa;sI8|DA)>!>-$FxI3Wmhu2EwST5UtC(YdYqQ;eih~US|UPCqeGJBak9|0bx;;D z=PZJn@$mX*Y;Kh6?ut2f=&88OMIC>?22^@N zFf=)ch%|5-Vgs(ivPCB{(cZaq4kLtPYt95`oW$psy^fWD&o;8zpNt_zq8M8eL`9oN zsHlU1-NmDJAB`AF)keq)ujN{M2l&*U~ikFOk z^2%p0J>JlLbV11q?5O(+(FkRvyt_Y)Rj11K(Bze818)Ides;^<+lep#(!(#J2)PTW zoqR&@6_3+A^7M<5eyVKVHh_7|ZIAUm1vrgJ*(|`Rd7RF|A(kev&u~&KG{#9!9w)4N zFvDWgNP)P7cYKXhZ#nO;db}23Dw{~RO7;Fd8K?7L2u_UC!fc({>wj&IZ-LXV!qNN) z!0K^YfJ}~&d^V3MkJA}&@&Tz!cR4hv-V(dJ7@%7dwMp)lwxu={K~5+cDo zs3N6~VRyl9cR}g~Lh#~PM0oVz3B#~q7zUob_dehK{`csIffOTu=kNR-{^*bXh`;~$ z|2`jn_~A;%iO5Qi2U9Fo_Tv#GFl{b9C`Z6k2oo_Tk_bVB-EI$Q;I_M>A9}w3-S4s6 zZP^Sx?_XW5=OrR756@SoM;L~||LJ=Am>T;P2vLZw$V+h%O8M`p1U8!uT>~)Z&kFzQ zm%>UwJ<^?p5o#=E0&-0L0JY`22FzuFP02=Tb8QxRnh!PB(|4PEpkkXB>jg2ec%5nt zYoTtY6q{KbIRWEgK5|uWTc7!K-qn1}LxWB$G|b2fBo^SbrVEO+Kmi92eJO0F!-+vy zXb4=6>8XzX->IFGS|pgKyJ=`(!d&W>W2DN#i?#+dmI&?TIyVb$B)@z?Q_}$A_oQe` zGF@-c#@v`5&lb>xH6)wf%scf)d(?^|fgicnhTRpV6h<_WuyG zv)A!(2$$+9RXqJ{kupwV7!LA+8Zmg#L$nrAF9MBq(stj+YOC)mgpUa=Kms$D1c{L} zdz^6Fv-;YAjrsLA$F%xV{3D(LZGm9!FDjv6I<)t8=~drkwk1YN3>cM1_LqDx{7X_e z4Rcme`emM3`-*ncfq;9QQfm%GX(2T@r=txpnK^h9TN)&OFDnpBC93+6;n=&&CpgcE zK}wZlzoiCcQ?f@Bo9~DH?BNh41nLUT7LSuNP7Bdkx^Yb{ja>(82iON6JL?&^KK`8a z;{Q#bGdV?m`oj;HcS0X#z=%aq^~O{!zO`>{ZViQN8W&5D7nE@0LyJT3p|#eSY0RaW zerM5X@I4=awtmT!NAHbnpWZ-#Ng`?bhyh>{GLy&==F;qN{8h@OaaxrL}0 zRTCB1UOaF2|OS$xG zs`n=2F$ym>?)UkFFW>R#ctaLtiFa2S*l1{@CKOATTs?Zk#~**pAN}3G&ENV@{)asJ z&TpW72ePy?e8_;AkPrt>0zcRlo;-<&B;LIG95Wa!unq8RzTkWH8IPoZzT$uJI~zWD zxF?b@63TG}PSgAr(Mn>#f`SA>A4!{zi+}JPw!imu-MJPPqTZZ5)%CSEY<=Lie~+a- zgHjSS27mq+Jlz8?-7xgxvc~J^KdW6kgAsdMbhKZ9pp2F}HAt6L4Dm%V~R(>Y3Wg zI90P1TxnI8?nU82mrl~aB^)Bx6L?91^jCyKtc=rF!!gPU$hlO{hv3#W=kl-eIGv<= z_u0k8s`{D%K!=s1t6UOZ0cH1Lv?%Yz z1YVbNmZ`|*eoIQ08g z82ULDb8s5xiBNss(w~Lz@c&9b;uRMSB)J4IwgI>6d$mG6R4=p^K*bsJ2ZC8eOCi_E zH>ESrSY2Lw@e!TH%$c4(RgDfZ`Ygn$^FpVkVI^IFlh2Y-TX3(m6g)4!y4KNJX9FQ< zEiHu+YS%W*X8c~_RF^KMCI{NfT#&kK=8iJf^Nw5>&S~wjR|XK-NA%myt=&Niw75sU2ee1QQZ=q zP5br~AyJUs8zSx%^Y9E`$7;bN+y8&;{adUhTXxqC{>GRyVy(6J&g;o@t#j()@*RUe z@P|KBV7{+uVcLyA-A|VK!2;PWEK9b)$P&mB5(vrS1tEd(3m{%-iH4?M8h_n3^w-_y z){QS1Q&o1kT=%MT%gmFR`?A)Gm~)PP7-Pm-J5N^m0=TMBg;aGicdotGiijBz<3IkF zA)s2ABH^uj!z{o!7->i#h1`TY)_93a%v?CP_?|38bmEM22VX!)84t`9M9QA!C3?S0 zrVNe1h|Y%?)tY;nM3(DzubxEL-HxNpV9KgZhe1_)`=`NzDHkO zzTa!y_p)j`hEf*BDTU`Vi#lL7gGksrmg+_4AUs*Yky&Fs7aA>qlR%A`RB7V*(@VUWH0y78XxmGFKG%d@4WI>O>fx zK_To#p$TVl8DM(`U7>DsBkd=cJVu)U^i4)o8fA3(y3dosL9%wn$)6$FDq|0}0CL2) zBMD0q9yw=&l;%MYvpDcd%An5d>KKZTmgAl&oZWd(+-$CBR%z3oaqwsPs*b2RR~2AW=#V2Trp{np2t(jNSGO8Dg2?g_PlnvLrtl{jw4FbHQ9O!YeiU5 zMM)`h>vY5FY#&*biDO0uv`{qI)ILlEM!EFCxnTVf)V zE*Z<}=PeX3ZGT{3`quqTtJSOQf8!AV>udkST%#P>jbYwJ~r+Gm(2dN%@GY+7%q?sMP ziI+16xZ;BmE3H|0oQ|Y($KDwOnRkc!-Hf#N0hIGNQrp$i4VI(1LS0MVYZD)`*Sp^> z3cckcy}KX4X`CnTy!WEB56Z;Q90NVk$d|C?yB*WxwHe3Z>`!;3I^*Q^POuU9K+5&B zr-@4kCBh2~b*Wn9sA9Oe+V$qg-AcecFLLkzObdV|yj9)_O@0Y0VM>`QIT(kY)+JHg#`%f@_FAgm5#!WS^Fgur zx$bLk@i?Uv#Z7d(kAV|Mz+8?QCqKMNd)aq5gQXkHV_O&}@%3@z2&kT2ULMZ8jzpxD ze_VJVS|b<*FTYz;v=xsD7w5r>q-7B3Zt%HEwn+6_CwTmPs*%@^kmMdQQfGfEMsrV3 z^@r-9jY)+T-h$3jxZ&Tt+b1PJ3nVIH-CbkL>%CZPM~q!*h>c(gnRkP~v$<@BOtpy*7gYno*LhRqmjZ@i@NI2l7L-PPrx0p<*jiLq{; z6nfGwV(@LuO*2Jk&KkGyiJA|qq;cA#;crg$IcDs)>u1LzT=3+DQ#w!YU-oaFO zw7NwSIALZq<>oZ{=lL{W)@F#MC4fOK!a8D)lNoo!xKl5{U|+A;@7fDgmV4Nx?nmDMRuOi8Zw;E9VyyVsx zWyU{6I2#@_Fd=HRmJu1yJW$dK6=N`Gm6#)(D6W&V+WHk(H*tQ2lY8&;&re%U@;SF| zy~BD)D9WasAeKB-Vw{-F<>qapltC!5t_N#myJFVDEZOe^0y3_6VlW3v^H^m{#my3TkP%JebQ>!?mpA>7W?@TQfIOaaPk)W zvx+=-U~R5#DzvLZZ37OR%Dl4*JXBCMttuwv+#7~XRL zK%Ftl`HXgBhv`hcoM{&>?ce?CL##CBp^=_H1X>*bZr|Sg#A6hg$LmtPc5R%AkRJOV z_b;EIs;nOibypUtUYFx{kJF%fh$P=W<#USteKLg-APHwluSxZK3S|d!lI18I;*J#Fi0s2^nvR);xo4?GylW4K zumf=NWT*Hcha$D#R|K%yBfvd%trz9q=|BEw5Q}po)RdBk8HJaTR+FE>6fXs`B1g! z{I=r|f+JvhoFH`B!8kVGA4@{2z36wQr06l@)DsjBjFTQQ zB}n3M>I~+elfS1kJzW z0}p6oGvu{NDVA) zJvC0oCBk@Y{`!&a^7W;^~ALYsW83xnsGxz)CQeYZW2S5K${*>GQ$;DfTIU-Jgdudx(yp9kQy3pryC zFYs$%m?w1aoq18kTBb=xwNa#SNIA^RqLAXQR{isHtE{9Tk#?B0aIe0J=+J^Ok_F{~Au&9u@y9AmiT^7+cJ?jbVQHxa=C7!0qRxz~GJ zux)Vw8%=^`j#Hll7ZKo6Y)NSY*zSUD8lT55LQ!&iyvB0X1vs6e1C-4cYsUQM73Hlf z=C`gughzL$cMZHSfZ0L6eFGC60qcQy>=CC)+5I0Y48Vp38`M}Z+w>_#!D=~=}SrV zo(_kA1vok5WMAYrzjC*)0jIBo&76UeBgQF8AmFKaJ##s*L&170l=_syk8 z9LM449c+VZ;Sf<==kUZev1`C>`Cd_^=UQEQ5{7s$_|2tyqT$ID%W^e(bIH#S+Bj?OZ@AgsLCuh8U}Tep{liLJm);$A`B_Y^F$bWE zIQYiB2&c2NlaqSXdyA&lWlKER-=UU-+KdDM$fn%19XIO*&+9u>aoL$h!knf{HshPz z$`5Hu1PUmXey_@LWc+jcfNv9z^)3jf?QIO^6n}6pE%}kb|87nJ38wsOH zj>I&LYs5vsw22&TvJ_2{hM+Bg(Xtl(eMTt`GpYlf&NxwFCC#gtibP}x!byiJIDAuU;g2akj&)p0;v7d`M20*)WuaK;ua+s}^No2v9$ut7SdhLxL z%bB(sz$#LwP)QilTscrlY;_aY*2px#4k0Ds`95qmuP~|0y+e~rbEWx}w33XNuvec| zwcfl3GvjhzB#-#DS)rBCRo70?mx$ zvw@S%ZDB?7^P6Q5ZF#VxtGP>yXV{UUyB5Z2 zaG*AwUN~@icl;Wd&xDG}qVGLHPK@GJkfw^<8`&9PKZdWQ~X)rGO3l!eJLY#D&7 zN1fB|S9+QPZGjkCYqVMrX{ZWWyGcC0&v9vM;=rksM71$oUSJp(n+?Lee9z+~zQyCz zi@08#^#W-5tSH`rS+jQoTZsb7U)_4NtbimhPM}9$u&@cOHk97!DKu*fD7(fu)y{Hw z(_iSG6_@R-r^&@I#sQchi(jXI^JaGK-}{Zo%#f=ish%9ppVaWCtxrHT3f;KLcIwd5 z5V-dQPNT1{IKB>?Bzz}EvWOQqFAA4) zRok-ms+5IsawXiscfkUjy5Fu*du%B^-kC*$)gij!;H(2DQCR@tZ0Tr0JNO#pyH9pN3uqjlqnL;0>S+ZX&Iyy@6(Sf4h&jI zUj%`cIbi<)4H|wffff<-6`wCOr-4=VSn)}1Da=7wSO3l~)tl)aCyPc##ypH-0p6bE z)z3-S*JaFtGfsnU*(C#VggL+}BKk{GY926&xi}WU zCayPgB*ZsQALqZ{|2(f=eF|;i!wG3xHbv`9O}$a#@@5SPm#p9G+zZp0J)^QNG0Q6r zR8e;34V{W{HJmt8Qnyqo3-B6RMQSBcsmb5#P@u%dOV%PP zU5vd>Oa?2v4`%GsNYxVt-STR>U`Um`-t+u;!C5YxQXHwyAEc#kalq|&O#B|KNZpZ{ zmnO_?&dy3B{E9d$C>|ZYVTXut^_e?7{Pg=kj5$vIz=Q--uC>P6bZ<_oi7Csvq_X98o<>(gr1UD8D(CifmL8XBt$DoD*0?rJ)N1^Vlsp7V0se@0h|QUnUupP zHLsU@L9<5EQ)Y8d$(T<#IomKwX46)HFzJL);_f-4rJ~wdWFbp-a4y25%{^Yaque|( znhc;LWk?jQo(!30o}4_STLZGPw90!VK}+PkT#^8IobSPZf?GrHK)KB?Bbr&lb1L< z`zCIld>gcx*%Z4x0P%dX!=w4DYWo^+`U=<RSuop_rB>1$$ z&Do`T2ga!!MUZRn#F)}&AywT&yr!*B!oUovcYf514G&ykIsbT{)q$J&phSYHaM;{a z;#`VRqb;9X1@%FoiU%ZUYm_uN~4 z=4yH^8bh%@)TshJseS8((B(Y<-;+U+=*jteZDBRxPA@62K|mf56Zd&L0s> z3N2(())_c4QmZskS~~da#9G9-!;~UeAXu7%Td==a$p)f@k{{rSdJZdA6)Jy9>j#lqsH6QHI>v4qe# zZ5Ie|CEv)fe~nW!k{W5V=Vsos>aBh=%r>;NiS;K)1XffM()JGGP*QW2%}mJV33V3t zh(1HiuYKkI{pUEpxQ(fKYyq(lNIt5;n&ZHehS&~Is+^!yXPmOP{qpEiI?8K4@9qx zEE`U5ocO)k1`ODzX&FqKs8A=uDe2x*jI>BRmD81xwRv+#*G#E#HSXisH@2H|npSps z&EwTA@<~RsF|8Gm6_bJ9-*NV_M;@|}28zsa|IBEbF)K)m>zQ$3P4|PaTED`!HCpp9 z5C&hfD+VO5No@exVs?VC_P_#lc8z*P&Y5Aj?a{BT{-%sm30a(;4p=qPUH25#N4o(1 z;xaw);(aLtR_Y1A#jY_ZwM8=TJks{n14eFK|LhJN#$cRGFKH*?rxw_J>%DhL^p@`% zzncbSeKv6W#SJP#edu+PO%-cKi|>&y?;uU6!^C!DB!Rphm~OblzeR3NQH>;2L)wnF zzwi%vvil`~cg=Fz1yH<*@g_IMh$3&GAAJ%1jXMkD)Hg}ugQa;l<7A~BWOYZ3Q#}Ht zDJe20kIAo%c^?DpzX)(@SM&0{^$0l0;&HOCN%g+A{mwRPA=NwbIQ1L z_GH&S@feP&Nyh*j;8X_%UhI@K&{Q2bMPY_P9Wo|L83t-3dx5hN4No@Oneyq2ij_{0 zH|j1f>c+LXO8t04XGHqE6P6*Uxw_n>7ugoz<@n&XcA(Z9LYvE>eKJMtXh>W9DO;8T zysb8nV#CXlsWpPmTkRa5%kz3*gC&>jN$=LRO36bMjjoT+ zvOy)G>hi&4=H3k)L@WTl9zcsnRv$oeXPlPuHh@!80jnO73od_(Gk9P>B+$MbqOA`f} zCMLa&w6vVtAziwxGC)ezgji>sJn5^Wz}zO1G=>&MxDe8r2$m4{t7yEw?{y7iZ8Y{| zc5THrBEFAW7HBjE`hN{)!6Z`k3`67k>PB<-lU1tjn6>x}F3SuSYqv}^GfEV)qZwKX zt5y)50PH{$zug~aL$Ek7;@6$U`-{wIkI3$xFPw2|DhmT;=7p?=UveK(LS4LFcGy?( z0)22T7eyZdMrw+YgPC=Pu|%R=4)(Ptgc{8`YH5BK2u4EG$dwpEeE6=hO#OGIMbpWn z+dJcg5?&gkS!FZNaTXPHjFdho>YmI@ z9|&CI{CE=})^&r{C9n+a+Tao5QGs;eu$pIYl9~FmD^&^;&0wHH>*Esq9+`(Vc@@d5_`EH}XlcN7&72yOo>TLh zCd%cwbrw3LdMN=(nVayQ=?*ulpmXC+gR5VBll`ZjP_%^&FC%FNW|!)zGNu))@MBIX zF%Eax)`m4>1x#Z_1x6b@8oy?YE%P)xNS4EKk^oKsZGTQ}#^X7G4xFA|A1(`EbE7=i zxy9gYfNG?hBa$`hqF}^pu-St~Ed#pA9!Xx?wIR3*({mZ}^Bewt$6JY7VHj_qNif+m z-58N1tiIt6>E^RR9=I(4Sfah3d*#fp>1~Z`1#DlJpoaA576|NbU!gejnNnhV+bG)D zof@c8?2xE8*0->F!LGSq%R>Hl2#4_fy^5y#%~f`AemSDs74psoYr=7=pX4LP=_%l} z`}iZrF`IlCOboQ1WSGQ3>MD^2_hHVH2ZcQ=Rd0Utl8gWE8`#{?RYFgXhUBU&;XGfH z>V0kd9c^8zcbuwsZ2T`dqtg~?m1KvxLse|Kfut@0Q|a`;5p5KHndY-4a*8yuUesXA zdjcWH@NG`s73-1Y!{rk|xH>tFAcJ;boUZMZUHe(0OD_7)k6-N)j}qRS+@4~b^1$1- z?lBJ|c7SV(GiEVV*2dM79s3JUrYp5BK<1jq=@48;5x)pJW2eOntD)4TL+ap8DHiir zmR)ql%b6#r^#IOVvq-a3z&pM!J&7)A%5JbW4{u1(`PSxzQ<8xm+hD{wxBlqwCiNCl zz39LNyVF9Rn45#B+&xYz-YE~!PiMF#TCpyuDRsISQsOkS$aO(gS~8zPFfF|M^nl6he+hxJEVZ+CM3-NYnh$JXE4WlI)(0`g^Gq$&tJb1izsOEPBPO0gquq_F(cLD@)YUJtuvRt z{)9bI_=p!xf(77~=+b&o?vlKV!#T6j69I`iPT7HXE^#ebzeze61PAq<;Xoi&L94e_ z5RfPmIzC$NKrLp}nKz+`V+7Ewx|FbbWOkF)^4VsvOY7K&tzT34y)w5#Xdai_c^@g~ za>j;Ab!JpEGi#rf1DJT|iO;2q^hW%8oM{vjstGs7hulf;Aj3nptIyI-U+4bW6{QC# zES|;ytKr*|;$dnuhP$upbL5#%LqW6rD5GuBf%TpEh*# z?W!R4lA*I2+jGt*qmsFC^CmZMzFYb>-}g`kU1elY4-HTu-*IW32tFnvJWgpiVw~1_ zVVsV`4m#sx=MfBX>)mO7opBmgr>I8rWh~tIU%kfaeb1KY_3a?lOYt7Ah>&W`0jApC z12SkJk5`CfwzsyZ?MWi!oM|JRf1U8;IcHgCvxC3Mt{g-U9(>ex?ty$d9O82C|Gl-! zSeubu3=EKrZ1Xk7iEDA>wlurT!yVIS&jFS>SIcpV&<%~xb;il1de&yF+BL?>nz8-0 zhg|)~`&en@+bd4L^QG&+b-Df8*Q9!1+kS^z$mhDpsm-nz@7tUbI`5(1tR>942rVv( z?$L2={h@?>deiPX=u!}Iw!oI+p%-R;6P=S6TROY+Y`8i{fXmY}tQ{c`jH9MMy~LB{ z@4Eb@ccG7d6U-c>sRN0jcE%~39M3+KgLPDK z&QkUHBP5AItH*Kk$Bfh9zKGNTyM>ONDCC{lYL=D)47#7KaS}3!p~{kKH`Xh%?G9^~ zhDtg3o=hTD&)2Wk7IU5C&^QnaX3>q#S;GS)7T0h+NcG~ADj+d4t4r;E>}8>{`qhYs@IM z3E5_sC2FQgWymr2N|H0t!B~nlm*p=d){U3*jt_r@pKaL zQ3-LZiwVVC{FkNr>?Dcdy-6K74+BGla9`*NLSryzh?-Tu=EP@Wb>KAM_j46*PR+rX z6pVewe{L-rE5^y}aySjSb1Q0)s_?m|kz{3Yxb;fBw`jtOeLTo_h zk=CYQd3^Bj^yCino0r%;(Q^Rm{*otqqvaK^z4qF*g1m2i=xn;Pa(1cD3<{r<%NNB9 zeHBvHqp$)8PGWX#97&hRaqge@C4tj8lCw(#=W_AP@A$6o+@*TK%;YionwgC$erCIh zwF!B&hL(`EFs&!V_8w>xtlTuuC@z1UkNizzbKh6XJHR{%d2Vcu!Xb9GF-P5TbCsRp z+GdcD4`1bHFiufhnkNxjX>338z(4cVv&CPw9Ls(_@&P!xFVF8lwOnVM_P_Cn=`#+( zR`0*b$#=YnuCGh^`t3mc7XDSYeHDJ?|Ms?bg+sJHtHHN9XLQ;__1P|6R%b$h1Mdz3 zk(zY?^nL4|5jisB`_H|I>ryc7ATEA+PT7muX^&YWZ_mNt{PfICyuHgVT$Acqlob7a zu;r2Iav?kHU{7irE-k=;hCF83gLsRk{=j)T*&>%MyS;bAqEM_yz=_sH zKQX9OBnojz#S4sFopG8|UP{+4-#XgKqi~4p;H;SiljI3hn30M{E%!M>76p8&<}xvY zaSA5Hg9F?r(r0sJYtD9d#IvvbJa{WlI11-5C#JgN zVGy$z@7&?;$k8CVDEzOE~>%uHI?whrpCg>eWtxXjLR z8JR>Jc>vGq1!$9CoCInZB#q`k010o3Gt#=RA!~E9c%Em5&NxYe@Tmc;Rj*0)luIOl zc}dV?)l)0sagtydZIL*FFh_Vr=c>Ig-0wLK5B$^?cA7|b89@!k5c{|tjf=H|ilNp8 zbbIruIdBT8o^{}_0i3Fk5DJxjdqh0~UAhZ(Imi?PORFU!y8+wm zzRt1kxJ=HzWD=X5r*h6`gUeE_4@ma4(_(Frgen8AoX{nFelFq;CqB5l`B`@V8bUP~ znBDs-?*Gc+ooaEIJ-CW z5C;=xoI@FKiJpd!jGQTa%Ow#xM9aY z6=6z3l1i#AQZO6q#q2)#`Ynp2M6)O1*UFfTAtg0T6H{%pIwQ75hCMbHPTGom_XaHs zB1%b(nLX7`oN>|%baZCWqCaL$7);4cF{`L}lHrUX`3}jTaK*XIc=JC|5sD})751CL zqcrhrGI5zJ8-9&xdcgReGfw~DOCE{dR^<5<(aBdrG{^>Bu?{K!JO*%zP=J*QbDn9b zAPQq0U>>LqTARs|X}b+(BSwZ|jL`%*f9JlhwQb~0zP`1 z!8p0EsMi{rbqO7)m&b|^_xhM)GV-l=%kCENlM{J3i=SP->vhlC%2QIkJjQc!ZcHJC zYr8_Nd*sbiZ%)1t0XJq{FixXIz?1@!>}R`j#5fs`izg!vBCLl* zvtXPgIpZ`Z+H~Y`%Iea_cyN@`*nRvFZClWFX8jF!-nFk?0=Y!MhyQ6vemAbAA?oaD zdAw)(wA(pOe(ycj-*D%dKCxaoXf&C=+P1F&r>}sm&r@0$rwCsFK)iU@^DXvP*EJuh z-CGAvE*IlqrHJ2OnuJ`Nff7S^Ls7lRwvx4_`wuYZ!IO|4yus$3H@&knjO+(DARhxF zF}NHPzxu)rc0;1)FG0NK_zGG48~(o*k-JTNVC!bua_{^B{&4C61$GFBh}ZU;>hfm& zkIfcpAFfOF`rtK)IA%KlCv9Hn3=tb%Qa)ls(z`$7$m3Lxq=Bs&skFu8B!HHJP-$5m zaP@EqtIKdp2TpN37oZ`_ys7Mtu%+Ydg|B;@qQ@P+A~#pJlwA4~o$soL7LNsFYLfZ< z*%=qZDjJ|I62c>P_)FgbzY_s~MBXE86v*HC9W4=h#-sU8^PJc0>BokOYz zL-ho#P9+G?WOm<^nR_X$OAB>j+XQDGXB7@YyS5xv!AL5M>VVlIHOwPw`#m7mz6c`4 zkC*i#x_f?%CXrld5{%KYFjml(;yN@^o9K)a$DbR3!exOlR*Mi1U|WN6QU)4%o>^G~ zDOB-bZVIckU5)F`(GU zK%>M1#~WXraf15eCD zN)pN#1@b;QVALFC!Q->K2yF>&TbeI9w#AZJ-kL`Nu8_P&bXQbr>g->(J>*LcZU}& zvxx>}7#%p(dhwK3``O#mQoTH;WqP-WZnQyZCef=r`mW_DpX^o8lf4^IEkpon5)q)Bk(~56!yRVh|~L5Y~H%!>KEQT zlIY!imk;dtI4z7*04M)z04GUUHFh6i-flr2a=aDo9hSk+kE# zI;TuCWAo@Cr}tk6GvCNe zll_*v=MT|H-2y`MZT&44FG9azEk+-}YI8O&K60LqCwL!)4n%?2Bf+&eh#6|gT=c*= zRXrSc|K5j!y@3x*?Ehw676i`lIOEid)z-Y|Z|1Xpw0oS4gM`Zt#dZhM$yyXp{`$q^ zWE~9ECGaA(O4Ss8gD6tPmLjIl_jz!7i-+qK57%e0Y!1cE;@p(O0}UD_y4x1VzcU33 z(9wxJT%qIE_p2QMZ!CgX7Z$Tkf+dRL(|h0tX&WK)TA)C5qb(_;x#@j*XQ^0vFP2}S z>KURj&r5@GitESYlYLE@If%_QkxE9Ikn6lijD{A#DHLVPjnfw%nHg<%bh*i5qscAU zv&KQrci1xoMMbW?XS2RP@h0Y6pXNg(xWwr(dTe{Z!RQO3sV4#QT&{abwp6S_fy5=o=sW8 zAv)VUcL`q{XQ6q4zvS4)Fk)%!Q=}wP5R9SD3xIVX7nfW^U~;Z+Y~OwO`NYrvcfj`J!-R`P^;AS zfUWf)OYQeMI{=a@!nSUpc`SnlTiDYeUHlfE?)ct?FrlY`CPL8-(8%hkbCpChKldgU z{<_X!TI{PblSxztaj9mJfrQV+^84389gspcDgk_uVEU6wb1`9uxKuB^O(}lAiBbob zc;>iISMyMu98liE7bP;pv(%-c-hgPR8UvLZE2lvpGf=VxSC15v-k3)4a_6Ym(USi!)AoiVPK%6{qj{0BD3asr%+iYt%LdaN45r%xlq)Yt@f& z);;^w?-7YAg5{g6n%@;4$YZj2c#C^TopEY1(;AdEkkf{Hr-}XkEk6H+{}WeNpI|hNyY$9A|M?&W%i$VM7^BRRbu^3&pzMFd-nbQ zYNVU^8gTl`*sO;`_#!HEJups0vRj#;g`r#yW!D@JZ!g+((bv;U(Ia4?&FIiVqff1f zOZD&;skTGr9l(^_8=$qazP#{a=Hw<-yddz1g|R#W<4B&=zfCE&N$VqE@xRlO?1++CB>_EuzLr*sTUV6yGsjb zby$u;xWg+=7w-<;Z z9i1W)IM##IEkoI2z@+`WDAJ6a@*;CIgi)^`f*#7kI7L@FlJk%bz-^huRZ{Z(77%Hq zE-w<{SlrmJ1wj~ei`Y41n-<{jz-c~$a>PCxvk~X)0J4ZMf?N;MSxR2|ME;*BX7EnA z#<_25pwaNKf|`-%U4ZuN_v!>!;|2`IvPXeg3K(p*JG3?Cn`{3b{d2@2oMKpWaEJ;Q z^Qrq?#m6y}eow)Rt$0Gfv7_y0ZXI;vhER(nVCUp|O#@2Y8E8)!FfEbIdS| zA<|?t`MFe6sLjVKBtKR!Zmuwd3o>mmUsKI!*+I^#6mm7twKpDS1rcW@M(gH|1 zh(3RO?(Ela!pqxPd*a^QWHcRfCvx+8<|6jm5!T?mghMH!F>DKfKc~p3qHv-Qxtf)a#q>FlD7RzwT2$lIkTvgH5V^=xp~lU5<$8 zv;9p+iE=3`c|3~;(e|11jh@~*7UAbG)_8!ue4>gdA zxKz)~(;3akb^uN`#=h;!GRJAx8V@^gN=iyfy$YY?O35#6u-vezVYA1h??3*?-{-jv z+vhgu*WKde+n;Cs&3C`(zV>6K*>_C4ugd_d)VX2jEE2u-x7@up?DkpP!Z>|(;-;?w zr>}&~;)W&B>1ky?Fh>FugHcD`De~`cH@fUBNI2ilh2erZR zT!Nk^C=27{J|tUY3q|u1mE2UXeetJRGm3-6tJNkvPAvj1l1G!*Ffu1~hCsvb(rk&} z_F}b5at1sxYl4iYi%!unNK!G>14$67DlNl_Y{}uVG;=sR;2x$v09SR4285tBJKJQ<@2@J{ z)V+T{fZP_wsU^SWl*Vd?Mt0y7MoU?)`ZL<`Fl-VR=NE_=dA;J~g>PVd-iy#7=4Y9@ z_fKM`pVsX6G1>b%6rsfkq$HKZKAI|i&zi+M^EcZqe5Lzrr7A-JVi-(Fxzd_@SZ}Tp ztJRCV=av5hr>7r0+<#J|4STYT4BI>YorWjW?Gsk!apc>$)~=d|Lk!j+7g{RhA#=7l z;ra9Dc=i7KIlFXOXudI%H+zgVG-I$mSVLRk=1L%>aK~GTG`)0^(X-*;g*jq;Bnf)c zfzPqWsU5LWx(UW9<^}Z#aJ||9@=V~={Y@I4pCO;2Di~Mqis^oOGqZ!oX*>XgA(*ca z<^L%@CVNN1+b3s>?pEkI=>&yBV?uL?it) zlU8fExd$`q#Y}m7i&Z1vU1KkuQcefBvu1eV6X<-of_q1^FgBb z{K=O*esI+E{whUIUjt5G0h>kibMI!?d4J?_>IGWE%CrE6UbGjhJYHQQ)+i~=v_~GL zL)GgB^;w0>h$FZDuhLLUhzY58_B(1rnDc7stT%xVzw|OqVY^C(dZ1%uo&1S9z2H&ZUGZfSo(*yLoc~CYCA~x>Jj5qVjv|D zUXCs+=`2x%0vMDuEWr#_l%6&STo1UwhY=&N8=aCD18uJV9rqp#(FVWyH4kBML_dO^lJu@{h}PmJti|PrW@s~}l;ga*nYpNYZu}f656)i1N9slr8_qag zlO4rTY?0K^!H|SJbSd-~siFmFP>%)U*nv1Xc^}zzGoJAN}w1I+5_X1)MM!TN*C?Yu>*+huuuXxSsZ6Y z;(lV}HZ4-U4klVKRXv_N1uK}FQL;BT(k=!&lTd36!3@nBYsFGXPsKZuz=P8hiY6{M zG1M}GAUdnm87IHzRXVUqv7Yuh1#t4liQlsh_Y(<^QxSii7t?+o`yknVj=W*e?`*+1 zp#jQe@eTRRGb5MII9Vi^`93u)nk^FkIF@jTmY@qSYb($u>U`z?Nr@soH$L~=d%%R# z{W(K33YC0$ftt|9nOF@?($T%nLCJ-kvah2j*-48vE)j$8tD!CH3ea}#x(;vDG2=8T zI**9(%y~?U)GipKlukoZ`I|FNt=b}6&qs{Y5G>0q2kd87X)j(NI+Aqlm5=SoPcu%) z!Q*7+AvZ_QOB=j?X~B@OU5 z1Bu74=~7BbeogjB^8EHK?8?wpV)c!8e$)5!;}ZM*)rp(F{J`n&{@uUJ2R`rt*6TIj z@g3j6&;8ubeaYAVqkr^|`1WuAc1})Cc=_d*`Lloa&+_2GgWsiZ`(J5$DpjwPat%0% zxbaiC2)Rcujojnp9uoI?EQztP$xx*BZqf8}jK+Z(>w`*D%zjyBz~o_>0n}&X^zHcbDuP7^y@|4q86Ez9 z%4+Z3-T5R;=}n+Z^~}dIM*ZdmhOu~@y!h$#ctQ0@s@E^!=4{wzf4OwUQ)`su(ZoY5 z_^cCLhA6_E2CA;;lBd$wfVAbtaLjymJngW_qOj;MG%u6_WqH?Kg2}Kb$~w~ool~)1 z;V<4bVV+#7;DD^Z|H0#AMDiLg)f*b_Q;N4%xzS5+Krt!Hpv?m)u@1dx=Ih@~$+dCs z{E{(%rUsB*RWB&J6xGj>gMJgpRzorrVE*VD%hij`7E(PT?3h$i%3X|;^>K;LuWaPok8@zLN2eHPB7q2slP}9tK;j*u3lR>(;E}A%`!z`y( z7H^sk!uiRTMtHvva_jfRzE2K-UMYnnjhW=Eu0YkySt_VBOb)QfaJRqV6771ueaYcp^USOm#HM&nJ)pVHwZ||b9Yvp>LsZ^ zPfQuCIKyQjUlk9B$SGLzDoFL?=ZwC~n%CkH<)oP;?&-za5pZfS_uwI+O#xin4MdeY zuf68$r5V*=d$~mwhRvE<+ES>Wjd#ey88xkZP2p*(xvoeeO!Z<(#*|k#=q8ax8JL&G z2VzVrtbj9Hp_ZuvC$geS_Ggv}86zh{nl~YCZw_EVM7VY9_mhV228(mFa(P&qZ+KIx z!Wdy5+qmgo1*O0;9W93Aff^nkJIt@rv>vN!8k1{9Y`nfY}j|kX&*AZgr2>7@GTrC>cw+47$>;8 zHV^7qTmN@aS$sbLV=ytT+42l#Gr^4sl@Zl-c$!_B`!wSu$%kg|s*&2|lA;MH5BvZh{_uzSC;#N1@bCZqzvl;k@CSdF zzxjXJtF1xP=TQm0I~$+Y`k+r13D!~&FYhOGzF^sZQ=gY)p0w3xybL9##+YD? zB(o(F8ao6gXlM(sff_SsoQ^zB=l|kg^5p;a&)L55#`3y8Uq`~!oWhSXR+q=jDKDvh zF4a4H#_=tun#9fALC!Y&gDcgBHes9^SYclIyjbA z7skmGw7lzRO-Xa(?)gKX-(+6g%y~o*1}ikY6P%91F+A}r%A=4{`B=pO2muZxj;R-o zhjq3T?ZV;{JFHI$Ja>qfKAfjOUER;q!A4Wwc~GgPQ02f3V*XG;;(J69YdMiyJ4B-! zC;^-nk5fa`0+`x?kd+Sd`)Bk4pNF;CrF*O5|DDnjPvO5J!H~5=Zr#V#8xp>!LkCWt zM|hFF?8>BrS*IzCfyQ64nx*?8h{<RS};{9#qGs7-*{2wDS9x} zX*vEq3fxQe=mt06pIy#~IulA}c<&6*fPnGl01t@!vW?*ZWD$6sJDT{|X3p*^MewNf08VMS7JZ!;@c^3NU+?phKBn1-LwFxB zyVgGbp*NDu10C>drmDvA508@>GYPTE*me;#kz`8U-~(S9qV9oev35_S(ozfH zBv>(~!JBjAWH1NzO1dyk(ryEA`uyERVzl4w+0P!7GpyIN($E`z?;mGxDtLH^BIXJM zZ7wIA%Y~mSV4wXNoJ|;IJ_7ebQDqb%1DOr8!c8{IyLIS8EBJ(A4#6zMh;or{=$9Pb#}m- zug?a0TBhgAH120lg)=O2@;To0fsI>Gr#2dT;;?=^2buIg0Oo z)>ft-MV_vOPK>K4r;EWlK-7zu-Z;>al-6-Q9R}bo`zS*1?p?Kpwo8s7h~?e2ee8@A z)$e7S*blpm{W^0`71`j#@3ZOV$ndJOmff#(%sAD$_=7*lw|vXD@VEZf-{Q5` zUgM{J>ZhLh`hWND{vGds|NHsTAN^52@PQBTNB+nk;m`fKKgZAi{LlX`fAjyco5lQu zC62sK*BK|A?TCpz96TBxciY6=;HtJ5o3CyCt*nPD96}C~$O6WQUtI<{#;@yNj? z$Xj<@zwO121DRzGlL)1ELVBSe58A#zUBXh1iavj*=&o9r=oN-imMg5OcLTdrWeF(| z7Hz&A6+}cAdI3&zpu>J#4ZL5_v4bAa61g8bB|S~#5#-ie7v^HzD)eQYYXgyK=&PWNG1MzrU$8BPkswX zMTbz=&#Ss8>YBd^+yvmCZBbx#sor2Lz$w`&kOJhT@b83#u-mnk;0tH&TGtz1+r*Ej zMKM$Tm#2ks>I{fq3m(2<3ks9?JaB2Gg~^+cB6`t!SotbK67e+~|C8nT`0FZ$jS)v4 z>m*44RdczbU;Y+_*I|t=p1IIT<+=xq5{X}1?bm2pqD9&d(fR<^Y1bp=VatIEViI+TtxT z??{V+3bkeW(j7X0SQrzbwZntY#KO!SD>3e8qJlPKGqojrU_Y)XDb}HNsh+3Mc~KeP zD;OvLHwSqQBbPnN;PLvD&p&q$fcM`2B;az*+m9x{zVd+O1e$_rJEY4k(w6FM-BJM+A`4N?NaO&T4N@cP%yP$WvEOEl zHV5N0pdyHk?26GkkQevYb>Jk@`ND=JA%(}OKzN{{K~fzIRUMF!yTyblMAi;!aY^Ta zamoxDDUDT->a4O$Ff)_iJ>q0H`1j8U17!hDA})b? z>Ag1?8m!t~PI-wJ<%NZD(gumPFit9PE26!Rx4GX>%;jw&!6MDK8TAF$WRS)VVb^S7 z8pdQGGu>5|PO?kS<|E)V219oYoazLvxEW@+4xHvU{aKt}JUM`m&S<=gaq{c)n#ZY! z)ToeGIb@jTvy=8aY2Z@{O(hUdVL#5zc)xR(l_2= z{lVMV9gq4}9XuSuy2nXern-2+4-C{*ZSQ8BbYA9FwOv_;;7UZ1=bW&)(jv4%Pe%t% zKzr_jbaQ0&!CT9*?)!bruI+Z8b7^6lX>Ggw{8@~Xto#~N1xpoq_1zw}FL?}mocvcO zZsOhH_PeZ2ML%c1-?QKEm%l%G@&tf+o|)(Qi~ZW~+BVNK7C{DP_<#5F z0m#JvSM77{djac-ZlzVXwl_C+HocC9C5pA)+3!VHpZ=2Yhi(5n?chU3&>N^J`!pa3 zk2fcrpWPzI=X*Fo_p|r_)xLGfpoigxr)Mem=zHRH8 z1;93!>V53BS9y|FY%ZPEO0_afmF))RGw50G%{-W*nX?ZG!=%Oh6%PAh;)Pe2K9(tf zlb^qahDxsgUR~HeZN@&W*sx=4a}=%O{-pp9x2~=jvY*Q?)x#=6iu5m8d`uQ{yGrwz zU5?W1mMD0G&J0FpUc|qP*#QU;CUycIEYAoNin(*E&n3ceIZ1TW%?RMH)FClU?z<8Z zhIR`CsyzXD$zLBU-Z6s(nD7p-0}|-%2**nY?ov>4HAX+>ObM9bz@8r1j6Qg^|7K^h zhH{YV<+%2Im~(iX48T234Wq;a|hVVX%TQ|JkIZ3(nUG2B(GG35Zumc0oPvHo-J^G$qz zFV-VfXMg{Ywz?n9|M%e5nla*Y`@io~=2RMDor#y&uY+e&3@ke8j-h?g<~~~tL2JzD zF_xmF5x_|d3DDlZPimE+dK0Ip@cMf`2-Sg36HqHacBx*FJwkZJqz@IYZYEb}*wo;` z=`C(uJ>cG>``p}}bHyn_;?Bd#uhG@oSs2l!>0mey+*1^#){vjUWn0ng0uz@5o5^Cb zF!4Z;Dve}HG6$i9d9Z;-JouDuG43X874om@*M|YLhNem?ZMklIAhUusM%y#Vh^eQ< zWg9$!(qO$gWiJz{MPLU76IU=KX`t#%sKIRgI_&`zGgUn8GZW90IJY91Y|hlDTJbRq zifSgQER2)Y=xK{l7{MCZ{F=YDxnw(U{GKogyPUX<=~{aY8lM(>Wx z_pGhbTBS_aYqK)X%Us6V8m$(enF!QcXjFuGt8JOwJNn$ zSWhq}Y>?&qnz#pi+8>Vf`Nb#w^}v3Aj+ukqX+QgMx3;{trC`&=xVZZ^`>Fl5>gl;u zmp+H#^ed$n|E+FcHsEys{(Wk#y!hga*M9!ui!buVk(BCq`_P9z#6S8+|A_DVzVBnV z+fhp4PygvZ&ENjpfBTDm&QJd2Px4p)>R)}=&wu7;euk5i-#WGUUv;y_7hZoI+0E!M zvVQV_Dz9Q@45cucdCpEPv{I?fsPjajvb8O>6(kbfsx*JNS}%6nH72IE#%u+%My-uv z6U`1#tLy1i&py~&Jph4yv1&{=IhRPeDs#jT8Yph44CssFZHT)NZ}8GV;@up zP8P53g$CdZ0EulL(c-B*7%}I`3*>3qQ+6)tF+gfzaeD--Ht+X5+CO16?Mc9AKl>R@ z9zG%McU+vzn7x7<%0sGWjY=g~V>V+heqXO?@YzS^g{ifQ=Wu0OAF_)F>fPUM`Roh# zI3HF#_c;fKI?bffZ;boX0IAk^a&g7!{De}X0BVKOD(ldw_w(1KmL+6f7mpvX+de@~ zXUvRUY3#OBWL9`wM4wZsz#e5|#@I?c*o1~MRA(-3Uu@xqpNXp8LEc?HX1lxL^177S zPZOzDrahEo%ypvF>g);q!5wp@0$6qA(Smj9QTR)t-zwJfk}@ZOT54-Nxw_zPT?dO4 zpJ07ht##;(h;lhiF(=8Ho7`^U-N{E@Ac#AP5@6beNQZ8`(2g3Mwt%u;ZmTKlsfN2G zfYY`2a0X1RBCRdHFY&hrT&`)YF&m5xEIHU{(FK`zd!~7Epiv9ET}4g~?Ts$jyxrd6 zZ2y1_7Z|Gm@gaOP=)%Uh{IA84x7r1Je*A{wg-}V(I5kmrT9Gm{ha53i&^r4yfl*RE zbP7#LQo_$<;c)_&>Qx@U^N8o0%Y*v25HT)J2WAzt$>MQxS>=&Tv^E$VIL!##tZ^OG zrC@dMOqWm@(xBx8Dx^7rOAzxYA z^f^uy$kdvVDoAvT>?lUR(I~AkYhox<%xUwJ^MN-%*>@X}#GP|*GTFEyq3)Z61LI^8 z;R}BKc)4V}@$i!U&gFhNK!?@N>BBtD)Zphdf?!r=)RsNoT^c*i7~2D^GlZ=Li0s#e zQKub-&w8R%X3Mlz(D{NV*0`EyPHLr~Ba#_wu-J8CUz{CRDz#OT$+CV0 zf39qITb?|Ahfyl$`^xsgLkb?>Zq3;5CRF#BHp=!28!Htk1!^hC=*(iR(Qq;2swDQ? zD-sUUE_atG32BXTRd_T_yo@nUmF?vfH_U@c9>0B`a(=~hqNM!=ANlAdSC<#q>MnDG zcg`<)rzGCmUGka7ALmy-Rk{6O;Nc_KUR`pv+0a^Md$otX(e@LM9_@JZ;w`M+qgCU> zpZz%Rc|4ICoXVE{G%>XSoA*4~Uh<2-@C$tR9czAimPydU5 z$tStN@D6FrBC{xAPI-}?5O6y5NP|I5!&lGj_St#bGNijo^|Z+~U!^z@(4W8?lChh}$stk{DM zGQ;a1e}^~PM>zk4OA+5}AEr&h>HQ6-P58{e_$)Us9+B+{@9-8s|35#QJ=#4;>>nmR z{Z{3pU+9T-_p$PXx8MFZ{KsGa*tOUH?9cw}^5^NXvVAKvoHjo3&Mz)MpD&b$4^G)# z3IC6u{WxbfGmd@^KJwxJC(w9%bDt{0|MD+?hBJe=-+r4CV@y8#!j_AZhrHe@_wpw= zv)8#QH&J~^Ymd0`Mq<59oWJ!^e&tT)lX=DJ+|V~FA9?s0-hQKT_wgG{ClC2g|E~$N zyA0zeIeX^`_aENl(L1pH)p~6oKJ|shM?deMKMX&IhzE9j^dtXw%p5#kem+yKl+QgW zj2{V4)n(%L!-3uKSsv^^&*%T&|CaIQyIIaJw#jD)?mSpAm$%>p*N^X)YrDGo(oEy= z_GJT3eS6nnvM2_gwSD9xAK^!T^hfzCf90?6C;r5r;PuyE=f{8i$N8Zj`XT=Q-~ap1 z{GGr2m;W+9_G3S`{Qb$3C%pFBYkbf5d=EEo-uy4OBfrCKo@f5gANdcw^wLY5zWP3f z)tdRU3J=`(ux>M3RV*n(N=VC~#yTZ-qNJQ5d4g3Fp)Ex~6iRLFTicOEaf z8ArBtUb@mgBLt#s54la|m%r-|@oQ)IcICQ}ZFRZdIzkNuHYaD?(C65tH%QgUDkL>TQViTYFc+P10^!!#DW~h_N%K3N z7?f9xdO|eKU5C;ORiLId!WCnkAt@z!VgKCuBL~^*L*PY;D(>WD#b&dK8AigmT9IpI zmfLead+Ku4_34_`W#Vc{m+C8% z@aV*ANes7cA`e`qstn|I!#n+LyU3Q7NcB$REv7tO_$cWi3<44n^#EeZdTu03m?J6c8%@-VQI2}HPB8LN7R4+U;6p9>Py zJxy_MvSX$TMBRT?`+YcNO0tD<5`(k-1zC*nS=yDz=W z`n7w=gNK+24^PiHP4|%svbxD?Y~B#i#A>zjum&@f6>{Sg!C1}k!T{w!8ozTV>|Phj zdd15xy~1nHKhJq?Y~}O3|NZy)>%=2IWer~_&| zbyiMq+~B*u`S)=4OTUOv(Uf^*c!AHAw}Sl>UV8B!cTS()Dl;xqm+)k~w?fF4My|(Nq~u&-l*&{(t0Czj2?GcYOUT z8y>e`;zqr}YajR)ZvUa*%cFn$I&XaVKAU01EAM?T>zvu72b{n28tKz_I6W9X+Zx4gi&{ZFs(AO6MX0Qipo&3oBz3m@Npg7sD5mG|D|;=#w65MKMxd%1J>yLi_2 znGZkYtxuox@&|A6o^QGhz_0!C1rOf-7|-APAm8xc{b9iCv!DIhpXHDL@juQmI52qQ z6OZ}auRh}5dro=(x8Gad^ZenC*MH`d%q!)O{ja}^J89yxpZgR5?|bi`0*rt1D<7ko z@yGwrALY*Kj9>i4U*zKA!tWC=yvmc!8Jnb>J^C>39be-c?|lbP&VQNJ>SgYI>vysL z*gK>7oA~DU+~9q8Ry_Fd&rzNie%~Mb6O7~YeC~5^QsxU@Jo`4* z_g-0Q>xW;sm^W#7M;{g1=-}n1CJw4^Szx%uS z>wo>P^YY6tzw38as}-x&yA6WFFnrlhRNt(5_dMl{s?X@@G0>}8k(4RwQl5Bbl4*#@ z5)PpeI8ghXBj}U`OA#0}hIgs`A(%tLcl;VRIUlsQ6?pyThLSSxyZ?m!jddt%BAPlb z#yK4fseR}o)JU>A0H>~S??s%69{$~++DKJp5SO}DgWBb360Ae_T1Z-#onHOnQ&zdse>mHr(!N({3|L#2o_I?CK zxLB>1_c9XmD6FK?Pm=qqfJA|uNnv2s zUu&Fv>JrZIaE6qY@24Dw+ODe`j*AM-U|7w4>M04Ixcvp^Ja`JaaDZrQV=bi=Eh znY6QXUY@oHtJoLs#5)EvJkzApMP87POtF%h4+b?@)eS2~ddgm(-_-%&BGsdx%Y(En z*L_?|!S;%H0$!e$kPrtQac$s?WVIGYNIl^(&gCp25wnC?@$1c4fYWB$!y3-lBP&MM z7&$ynVuxde)x~3(gCW{yXAQ)>XqQ-ndK5>V8jCzG#VjbE0#VXBbZ?6(*#lE*htDh? zQ1yS67&P3ZxfCv3>E7wDaeQ5F+^^ey`PRit2eS&fP7X*6zV6{?790;Clcy{0#pQUJ zB|?QBrPDZ)W`-8dL_tq5^e|&gV(rJ5ahYF3O`Urc*jQ!PvY$g~Omafo5yM*JdXY01^R6L>52iSU` zLrE)A0!zm}Q(;AQmRTxF^WdAbVznCGL)(nKt~iTDR?-Hw^N>XgO)9D`H?7maK05=Q zi?XWj^_f;9IcHK**6TI9Nimy`nmtNQgTE##m@*6la%aQM0ZbbEmVpzJJfs21GAAeZ zVD__|X-tEmDUsQeY3{9UYqB*gDXWy+k8IWV(=x;WTrf0wL+*wsIVtP)_^$fK=OYTp zKoVm-oe^2PJiNl%48kLO8TYr1D3aZ)tEwdR_Z@Gp5eB5VbUklIQt_ll(kZIvq$h8? zBsQw%QqBZdgWIDn~lPbskX`G&l( zWwk#2;x(QLNtN}<;W&+}o2UrQw(t7AYxQDNk}9js^<%s_F>kC^LvtqSo}>xYfpHAK zk&cK>45=~<1FO|)VLH~Uk&C2E2AM5GN^CYSaCw;!DXd;NWB&LPI4|5tgEy~DILV1| zH6S~e>gq{j98cmqpJKLUxTB2Yp*~x!M?Z!p48y=~_XbH1aTKCu**C%WcYJD1)octa zZzi`n|F-IB5%nR!Nuhpa)Z@RM&;PQ8LyY6dcYMcpyo;jy*`NJcKJ=jvJ@a?2uC5j{ zUEjK)ZizbnD%-5JB}Jwe0M|jrWP!OgQ5tT{oQ+)wF!}Jh=Jv zkUDor&$vBh)Px)J=${uyV82=~^QaJ|tRz5_3mZRwy23N{JK+V|Jym6)0ZdS`wsr;V2@^;=Pe|+hZcjoGp32XF)>(WSy<;s@7LX#gfG48!oG@CX>iKs{QRow1HskT>2Ghi& zNHEInwu3_+11o&h)g@S>g9+bn;-c^*F$dXQVt7b>6jKifKr!t_u%G2#YWI0HN4PkO z+E}_ZVxOfq4V+nR62^7JP1NzOMUDoy#y45n3Bj0?1NWC6 zKg6oC8xr&2#cu~rzP7!C;e%`A-qd{V(l#ri7HN4A;K1Q`ta)s_X#(wHG(Q$Y@6G_k znwv!z$!5db2gLj%XEo!#*=#umRcr|@@%3Y|z6>K%n?wV`0(7}#)#b%XQ3uPnuFko8 zaltE(KhN?dfxP$YxhBOUzTNlJ<*MB~)x{XC>T)bZN6fmP&|j-d9Jx{~68A7N&hlmx z#^#%5?OMg>4I|vB(k+tv5zaC?qL< z4BH7Qp6`iF$_Y)k@D}3C)Ebh6fh`%~VY=l*QmxTcNewg_q(w@2hzGx?HSty48d66P zVYPa9X*b8*F(J7Ob<^c=g3XNq$P}729!xW>8Y{!i{}Ci1F%}}7`KvKJ#V+PXS*b9% zB(FVsD;D>90ZnaJsFyP$kndb?Xg_NJE<_+!4AV}79_pp=2&JT0_M5Z!hYEJ@Y6(Yp z)>fa2BL^5_NN+6{U-b9j5UB8UI7A*}j#)8EZM0z2MTgieqe^@y^J9M;Nxr1)*&ekS z6=57*F4x)~J;~@gVa?c_Pq8C*nBjCWVKi)A5Q%WAI0m&Hq>pe&6YR%fyZx;H!_sIz z4u^R6u>vqF@iSrGHGVr=KgC}*0P>%?eObTvkNwz>@%R4T-{T+rgMYwBKl)Mr!e96c zeC9Ks;fH?chX9w^egF4=|ML1j^{4(6|LmXrGk)r)eu__g;uHMqfBmod(I5R$zVkc3 zlUH7O<;%4j|5;l%IU2^3S$O@T(P~|Q#25umQC;XkFKRmL(dQ5OEwSoT3pj4*y>q#w z^+nKvinzxn3W8;F(2-oSMZdEL5-1aA=?NmvcGY+wOp!Pxuy~w2973)=XnacnTzcUu zm?U<#4o1L#A(iG5b@igLcZ@q@redUEHF_Y0z!GGz+z3j+7DH)6TD>-qHDP3nft*=6 z<1u4(25HIzGb{lXx*U7=Y6ygkzAeYQs8Ui4_Dq?Y0BU%g;L(_AB3!LTH`t4pT4EZr zTAXp{j8g}A$*M~&BhtX-b&Aa9z)3?0X$GoH;<3Y<>fVi-grfZu($QKFYWJCh1S!SC zO1lvwNRTGBfa*o{78Rf!Gfo_(>Macd|DUytwbXxWS#t(dYdtIQaDw_^PI0*-<|%5X zi4uS&*P9?vCMJc2g$uxC zz-1c=^Nkzaj~FLJ7C)Wg`%pD5k}!eyYq?m7VyGWm7-P0e!bo10#(E&YqFWOfWP#oaH`DkJgGlM#K$Y%_HhrGwotmvyOL6`0kpr57LH=Q}?6 z$t4N2hl%Lq_kdXy#aOkpctgeF{(>%2PzWJ7DT6f8zGeu~t1TziYat&$V1R#J5d`)YXiJe|3f zs4Eh*f^xMqO)37AAIxQ{_op4!j1@xD0?g5@i6+&J5o`#Cd`4Fh3Q-z1ocZy;i20i1 z!Ao8q#sKY`Bl6UDJPg3S4xD^6hu_XpzMiNDph;-aXtie8b34fPC4p0UDvlgr7-GP1 zx%{HP2ZuQF^wjsygC3p{v&W)?v##J_ffj$305Zps_#z#OJMO6h;kNq#zA(6JH9Z-r?@$lqcZzXQx2K8TYP!yfV799YlF* zpDjl4)6E;)UT+!F-oqiH=$X=R=-7wH$rI>0d*yH5JE2iR;~s*CA+1u!@MM`wAUfkjGG5kCu_@og6C2p+ zz)p=4k>JOSlk`6{IXdn_&54o|OhOq}ek8SmH7-{JB_vW;t5wJ>72|}LfzICTU)F`6Uzh3~ZpLC>6nk=8u&pTtNc9khY$rga z$s-c4#l94p4eoae#zk9WN`Aw4fn;AOjU8}a{5YHfg0h}1{B(ZN%yA7_zwMh3!o1&Z zu$guX+*=r@h|z6P=vjb`HuS>TFTx)4UaYWiBI4_Oz=5x7CCh$Uw+l;6G%(BoXtR2) z8KOrS-0pnoaoS$6ClaZyXiOlUn01(8c{~1mWi*29CA359*!1g%Sx=@ zp6%&PfD+QH)|AJ)Q%+^aC~%U`S)DZ4-aRls@xY%|V;%batJ%Th)QxVX-{Dj!9$!k1 z2A8G7Jp>@n9_Qa;Snv?*y|Y?EzdOWsG}sp%y*QVpPlPU`5tMmfuvKTfl|37T%8hx) zKApH!j}`Om%`3Am)nj3tauuY`A(57l$QgNYE-K{Y!^_2!F^S^7#j`-o!P2wA5kD3mgLVc=FdDpp20W`Il)v(?K1v;wtzoth1Lq`?gqYa$?EY0r-`)* zS%fqjW)&MNWROsrXbOqo7h{}CW18+$>lW34lau$e+kKwe4nXTSXPgq#u6)USf~Pm1 zr*>$#ezk31_Hc+F{^1|yhky8opZRb9@E`uecm3=~e&k2^kstYy|H|L$cW-M^tZP#C zQMZ@bC07WH)jNkJCq~QcjL=DY+1IF^DrGFX^Mmm2AhGf?uN}>Ya?gND_ng=Qm1HS4 zeDnIa>-%G9;PNkrNbflxG@{PVfQUy3_XM#JH(?QhAV~O9bQ!2PuwOntSMS?u0&ydQ zcS0@p;TVG1QEJ-a&*{h6lLSSS+CXci2A$o9WD@B%?%-B(^{)Jshb4Io96(m_qD3RE zK#YS_PkjE<05C9WA zxw|6z1G#BKde#du1IM-{Q~VCV2`>_oZ2)ux}iSkRJcu#6hpGF<&=DVP!*nzed%WL7Z_?D>Tc? zq4dJOV$t=*4AUXJBH`8HI^(pO!q*c)E7S7)(4YhQ3@&1!`x^4*fi2Rr+Gic%Are(P zbo1e~jY5?~VMgunSWy}&qV<)AN(_Px;A9*arw+FLzR<6A7G|omT_RCj_wI=%R`rCf zI&cDw_+v;`5i&(xMCG_x-P{k0?6B(;)pDGpzSfMfRBmi1jwP9?&PxJhM|Em7WXJAx zF>{ZT#peW4^Yf#+oYT`XVB*)QrvlGFIxtS=pbT>OY63U`g+hpy5sX4&6qgBifK|1z zr14pcA-=(UdbV>k8Sv&*amGoaNH1|JhSHpMJluu>NPG9%%t_f`3>Kax>Br0O9@1IT z>L;QFpl_y!fFBEWfW?&+YoyO@+HnGM$<2Akll9K`Sw`v!HX;2 zzP#j){2F}`sw7Tj;6=N^<2q0TR0m&%0#Xc9amibUqY<i3ZvV=K%kVr=97+HXaTiPjpajvk&dK3(J*bDN>Bq1K@6 zJXK{5Fd_k*WW%F*kJTX2BMOPh?TAH3QoWHtK0;Z|XF3R|$b`eikqF5jUn zz-hzNTc2YYVwgj(Egt7a_~)W&(1#EM=qj;$Zo}|Rcexz4Q26aLPU8(fFTV+J`eIT& z038(eFz+jE^AvExXdMUz19XjX${D7LUIR`C@Mkt17^kbs|8(OP^%OYYB69_*vrRHA z0A`ux^b~N)`M}U!UIyE=eh(=-c&3e0qWdhR9WhS+uqvVqQG^`CMF1_>c0n!CM7T(Is4^}EiP~X#c1gjt_Yg0& z;)_K6BmEb=)N7&rwqu(vSsu6DM}7{rUu0FO zmZeaW&N$J$2FEa|JRI*cJLPg%(AM1@0r8H!WX(KuLh<=jeb$TgVVT((uAz9>yk^&p zw_u#QD8?)b3W#E@-|dB()mf*Tx0i@t5sw~!ydI;76{;$`arEM5@i@Vf@`fNwsvbZk ziTg`1D4P6O&fZIJ5e}iPVUpamjTfOBk>PX7aqb*EWGlhC#0rQGymmj!;(hYfSGBs| z21sS{DDM8+S;GGjph~3YD8%sz;B;)-m;R*mV^V^DTMBWY4+}Fff9QjQNrR%GjDXO@ z*)j>>Br?-%ptKC;g-L4O+3#zz#b{}vQKdVm`q78gu~g5DX#szoaq6>k#EXai^B_c0 zcp$3iL8=E!RC|rWv(eZ}p|%~V9$FJQqbSdwERQEPcngVg!sXEHas)??VjFHH;%ZFGPCt z;+xWt#~~W5hf7~;!1zAoc~0s;%nTzr=mm}bml2T3wG+0$DGzh47R zU)z31TMghOdIX&8(7|2>aF|u;X|Vm)to>#ZMTnAVIxy=%(=o_^$e-p&Umgz@As8p= z{ni7I;D426f%rf^r_l3}FwW!v@}?9Qto7dkwf&)6%7ImA2hjaw4HpxY8)(3%4$lN26~c+DIaz6zqkP$v)%hj3`w zyW&SoNS6&*NYwnWQPL2&HRKf5%e2b*dbNN_L)fl29vw|ZEd?06F4e2zNHp6_5_LI? zdD>vJwzNLO(ct$L$d4u`o`49GbYi zw#2#WS8tQXP6|aPqzf6u$UbqGE7p+!*JWM@pH)3>6o~iym%to_)HM8$MzYE%6|Fuz zyCh>Gk!(e7qXQBXh8A7!Ry?Rcb!i7X<0OafFc4`JXd7r2!*t`JngrHUVJtIZFw~=L zM(J0rU$^l!eJnurHNDp%7^fZ%vA8>+8Bzl>hbv%QhN3P{}CX1gQWz zMIjw)T*SjDYD1eh4Hl`Mc_A?;mwGvK>Y?6!eYf~pwKobx+<)UG(*c~}ERZxqXKzTg z1Y*uWUZ?|ojW5>OCCr;V4wjTYh_!cdJO%O42y@`nuewBK&BO|-aAI5EKT~#jeQ5I3 z?h%co!iKYmu2uGRL1UHX<-SNx%xQ4IYvH%Byj&8wxhJj!+YUq`o`$KvEi(mIZ3aBJ zM6;4LBU+dHiqOyiAOl{Y&MK&;#KQy!tJCl-p!vy%pUJq^I@j8n+2TS%RA zI)DX{Oewzp6i5M_YT%Ssj;^~hvDTe`mzoz@t!eTBsx~7!lEl+-b@niY$?h;%2b-0w z%3OTitXrj-@P%Q;tjQTo04rR)^AK$#l9bhWy{Mn7f%rAC0I{-n-*7Y{kj9D`L?~@` z;Dk`+3e$#4z6NNBq_}Dm5-JL;At&zLvevxewQ|O(vrXytYVk82Z=#3r6KhX-X1oLB zex_$IPN_3~r7WQgUko_4W{dpnnpAIf3Mf{MGJkQ_={IGZfO)Dk>)+!b)iW6#{I=_i zQ%Z?(QI+^-ud)NVr{#8?bt(^b?$<62c^F{tbiT$?r7yxbi3lls&9U8jwEKGVUQ!Al zUocLs9M1Q%JWj{^Fzw10J7n+Ldg5qr$bPkLUjt5G=B-QhL}j@r^`?~pV@O__$Rd;J zE6rUo4XshBN_P2@x$fNAg5}XmFYUc+7c#e{_-l(v`yjs$VO>aLmT-th|CeB#{QVD7 zy|{@K-S5he$E=Dh&-OSmWSvVri5(@UYgF z3Ej=arFuOrDI{dw7eMkG%TQ(nD0%SrP>-)p^gxeZ-g?bq%SQ_(7!A>MbQ~M|l-Ldf zhH$HRw|2W;dq-Kq>VEyKH4Ng0_Se|Q<3@7fNSe|@Q&^wp`%t+=P>w{pkS3$Ngci`a=J?b6^ zxmBbvid~cHVV*dtk;d5B17QSd-nF(dQHB_tJnQH_t&ZTa<$Qum*LtFxnm}`j z@TS4nfAUwkb^fcKiYP9{JB}mA=3vWWe>I?NYYR8!!4QY;{62-psX60Rt1R94&KCE9 z#4g?Scb5Q7z4erup~bI>mVC`9g4xKfhe2BRI4S*+?Sr^|O{ zQ|spUp*@F&P$Gs5oBO`1bjE3hkbt&y08WNCki=M|T`Bw`RmA0+{bo{qE?@Ui%nI6K z7| z*&hn6Vr6nkvG|pM_{a(}sfTre+Tf;34{qv6*Ck^JP%m;w*#XL@(ZG!8JQyvsC2M*J8{> z9w&el$GuF?4u@#6a`iy~r_MN~lnCrcYM$!18Ui>y1%6ToP7imqxv_q@b0y48!S3u( zc^2bz9XR!UH@QzOGbwEthv!iB{jYT!GQD6nlU_UCz{1LN6- zD{cE4aQZTDJshI-?kOBCDp*-vx}0@MLyH@i^~ADXgl0?`=Bz7qGO*D!LOY ziswU*T^Doqp$}|Wvqh$ox>PM*)H~~Q8kT(k2US0Rw&OR}?<_^|^6Al8bWj$O5FtD$ z!f9QRO?&`ui}?u2_tU(|?B78e-DASyal+ZL;{#pm(#2{<%pUQFaQC2S2?L+L;rfW`D>?%Gi?rRd_O<0mjL`ajSTG;?;WNMYXkv>;;vX z=tm>yl3b`(QO#tj!CGWDL)R$alNV>&3%cmaCh8IbG3U%218jRhKu_(<)@W7{RhJbR zF4gn4J7!R*feHkZ0U_a%B`<~=$1xpVFTB7LK42dsAB79_Rdy^*G;x!-gW)bm>8xom zPR-Y0P3|$P3ew!;)MR!rsmd-XRl(Z-pS?f(wIs{VJh9)}dz+o%PCkUYM?_{s4rCUm zVv$8s)$9@7KsOptKS+So(D0xaz3cyyAP5bi8xkO>0hOwOs%nDO#UWYAAv2koF^7i_ zcR1&m?Y);C*4o?7b-xiANeD<1a7!lB{rWxU*fHB?w!ZZZ%MuKmB`J8suPvEM)q#fC zyH`t>&mU)RK(ypIFcZCCp0cCXfEl$xq;{YM!Z=$8zWL;;+I1ri0IU~ZnL;K@G2rA^ zQ}h!2TGmXhqmE*Xuzg1MYu6VbXkKa$5r&%j#b=%*`f%wI0z`{VPIa(iSrQASs6Sd{;acx=1{S!P1;=D|Dyg*-@S+vXwJ(BpR9gn)!ZaetYJ<&qY}<|6y^ zp~>~?bjd0iTddVswIBiFKrRK*Y_oJ2IKO$0azmCCN!F~Y4}@;ODckxBz_+fS@mOE@ zQgh(+{3)R()~9DkjEt`o^>eYH9MgIRD>Cxl8k9k-2_Uc%lj_}KoY-N3J&jiLb+$Gp zsf4|=(I(ZC)u|=sHQ=;5MXQpZeYwA>ZFeT?X>Ie>iE)wY9Wx-&|D3aZh6G#ZcWvd! z-*gLn#Xt!5ouicoTIBC7@ajI(J5CNf<+o^iD7$-HUUT2)z>l@>A z-{xr6U4~C?Nc(K^$L~eIcYS@}ROMr8RW_UVtr-#xl&Ka}=Y`!%^4jaGH%A7a4|Ujm zJ;tf_bX{ADqF?>{e;>Cu!0DH~b&u20e5!gxQw!=w*=p)zwQdP5}{1SSv?! zcA8&9yGRma1oO<{l&zr1E@qh5+aL%%)TaPU|C>VL&3t z>^p9syUaqFO~T{>9YstuW8<-_N~QEc z%;3PO`P#5>2q%dL~6_DGzuA}DR&!y79#k|lJxsxgxG z+iyRA#_8dj_g=PHDeBjZuRmXpzT*tVI^YKx`s_MHU8dC5o1)r09WAgW(}otL7VsZT z`dIwfLSv~HS!e_AK_F_j*mALOh;}^`jA3Z8_)4JEmbmF>OBXo`!J_C5MS)1}^5&?J zCIevedP9;X=o>ghaWA3zO0}J{pIL!xNsZY-v${9T8w4ILs1o{ms0@fip34PM3n$G4 zE`gizte*#}9X%DFxK@J&PQqtKDSE=E>o&CxhD_C8cEo&v#YRy z5DB3=!)EV!5CeK+$>6|=n1~Whs_kn|s`{7&CHin^#nvvKaHplPDF;7CLey)d3Q@!( z;|mh)Sy_uo^`_ApX|-B|siZ^;sfjTXB#}L;J&H28baaPyxmaVI>im*HtT~oKWZ0as zUT={Q9mo`75L6=fZ(g9xWZ7^MG8Y0dR-#k}5wfS=wIGn8W(J*EmCD1*D})1Q7mpcM zD`Jw@=3TbW^DdP&5$B8qi#yk#gfX%X77Uc@48>X+3*+SX$=00piu`h{WIWbHXgU6ddF-{`PT@BxGTt@0jI;^ z<(;oRPSm@LEr~AQJ7%2ZC>%naacWY%i;D}+&(C@1op(rX-VF5`L0CCc_bT|26uL(& ze(ntZw=ZDR>X(IS3*EDH2XGn!DlgHZjH^fX-ZFH+S;~G%)Qhh}g~m7yWAiwDP2kiR zS?nCX0ZwnWUwCVCoa)i3C`Uzq49bw5DR3W(da)7w&pqxqjF?;xyJ_{uxarhG6SIl^ z)La3!i9+Th4&icP17s0sHO5J4v8XL04obAn=Nyl2h=LUhepOh*NUh7Q3)liHB3prJ zM(E(3+F-?!s&yv3(5zU85v>z@Z$(j6EA&b<&yA$inKYHcb2p%#?FwOUn)93W#-)(PA4Ii? zgw6(bsh%L3S=}fD*^Z+KMH5n#Ce;&+ajKFQ#z_m0{AA~p3{ZiyHwk--gG6F^1Ao7G-T` zUFI$wtzj~GTD7o)W6#k7oIvXlaOwa=dpSMk7Ur;sP1Os$<|#Agg-!;U)U@_)|9Y~u z)CNO$;DnWaBE~rFL!q!RPQe{enF#g3v#T}g361;o87k((Yomf&_=}X>Qyxu*Y6Tv` zkyOvGN(rdU&W1GtNr-AGXKlWj1(6sl2i`sR3o_7rKrq&UZ%t3g;}#W2HB+NK%(v5? z|L|}BlyAR$+4dMsg$||ba%~}jm~B?v6bE9hoe`?yz@2vdU4AT;QloWu+k+iT39P|@ zQYN}sug!xhy|_03Xdb7bOg(lst9g;EA*4Q+%^FEPRnOOTZvbeMMq8qyvH99VZt(A) zCR^vzc*0rnLWjYIfLHq+LDAsx^9~H%f#&Q^YtA&b$rS>guG#Lum5554Md+b3K}`H88cEro~7MQnfqQ*#R4K?>TX;XSgWfg32?`5gCX5#?V`H~_+Oo1rE<9ENs`RO?t5;+^= zG&sO{aPtxoWeO{{lKI}|+E`BtNnpyxFXBLU+M8$hd^+%3pL~ua;jJg%w*9=L$eptS z*%Wku;fF8mHTTzFDbMQOrz6HmyWG;e$9FPL{n&qvV2Io#W_K_~J~wGT+&u*Mt~9<| zukTX5vPktDIAwLI9*b0O7zTd-_kW-F-g}QR2%?iWMRlNDrMEs!ACn!+U41 zFJ+qRp#RUV7x|>2)Sw??D2)_1eQXybFy#B-`UcEPW4b zXRH^mTfzty1kFS$JagWm+va=}=U3QyEtPdaY`O}edIFQ4E7iWLP&G6LsNxG-c{?mqJ zHem190gZ9;#7aCSUGRae+JWa#3z5v|2~Z^@nxxd$seNZvA?1vEsK-0=1Ab%v7HRzi z5QbdIejUVW5#-v#A>6AZ!H-pS`Jt`aSZsLfB*q(sTHUMUzvAD%)Yc$S=IV^2dbb~A zr)=gN6k;#l>~!T023ylc-1FE1C`zb34!s2P(+G`uj?Q9X-WgxZMcVmY*yy0@g?$4# z&N!*E+pPT<2qg@iox}@RleIOEpv8LIwK^4r<=Btd(Z^HuKa#?%hQR0^>P1nv50a_v|qzr11xPB918%!E+5lr2HrL8c(Z z?lF_IgX?;*CZP!G;Shx7`K5q(bh?nODJa%Rvt?<`m?SQdMHuT9)MzZNuQd^CZdfC( zc!R`_QHc>vX<6^?acVc-Aj;@*u%;$UfrFLyH`n2b1=LcoF_Qq62; zo6|PMfh2(;k0!Kqsoq@e+G;bi^T8Seb}uXFgSSZTPr0keHII`^^}5Gt_SuMnIyhYU z12pHEl>?Qc&5zSk^cLVEY|#o?Cz_mEq#`HhP%E_r4xa?_Q=P$Mf#@Bk;->dBnaQY>0O{%9ycY(%Iw_1}heA&jvq$u;05w1=wp zq6{xa`wSmxKW*YI>p&O@C6?Nz2?^Rwx>Z@?$YXUtg-gJky--~kClT|ql#0YaP8OS9 zT?Un$1PR5`#Vs-S zDn1xfwa0s-ipCW|gL|ABa56SVHBdZp&48YE;8azQ7^kv;cB}{v3Zc4}NTkQ?gGK*q zbk9{QaGNzm+BIU|VKsTYtFvB3q#s{<>xfEaFV%~5`wqc_UNQk{W)hoqR%JFxnn#o8 zR!}xcSZ!h0K!D(^vo#m2>Crq+4JftLy<^#?AdKG0%pNUXsRm%h7*9p`=4XG!$$ke4 zXJv~h%){u6Q=tU+zLeR)z``uqJT(WkwOBL9ubNn@0jH4cI@NYhvjb-xOQkw18L3bW zo;To@eJ zIx7^cKo7n)k{4r_+ZBZwLCB#6{j_TbqNpXpsRcEt8iSPLLIMl-kUL&sux4Fiwi*{5+2+~(&*rGwnmW%B{XKjj(d{U zgb|Y7fW{u-FPaheG&aAds8VC}pd&$tNYU3BCw%>nVvWqpQWmM67lw7dCaW<{DF~PQ zOq6JhQ?VIyF$TsuW9gug8rwOxq1s6bDF{=x`}8}UG|BUsoTrj+S^4h)~Z!PeHBdOl8-zmm$G;4kNp6xr={PU%HUpBxNU>u$R zus{54Nk=@|mPEa~{ZsAd<(9|Eo-ZvNB4EA?^Zm*aF7_(>NlHoy6ho3}R9 zA(~(56`*$f+BQJ9)kZ~}U&-mq%G=@(#}VDXo|0ZwnWUvz6y zy<28_|KBLq2~6I_pS+&X*1hxxYN*zOJPf0y{0ZIl zb3Iyr)unvit@dIXFOJM;zc3=T%R-yyN_srK_`0zrV7>Y#(;V_-`)8U)vIH;J8UT03 zDR`0Y^Ml0wif*B2BB2(Pn2q_!m zbdbSf#=(nSJTBjkVAjDwaqUve?B^xnOqt*bXhRRxs3I;?^tE24g9Wtq`$@5AFFOwQ zK^Q`_bzQ5iIRo4F-g7fON&6gcMtB6aI1MPp-ursJp-MqSj2Vhyv1*DCVkU|=h|~u1 zst9AqXiwEM)-5;-)2^=OP0j9?j4~ockqTp-%rhzCm9l^q2TnqY70K=+3f|D7ki@`J zYlhVnnflx~2Ts-E697UMHaY{!Wm<6>iqCKo2A8HDyb-c0#yCxq2oaJbYCCQSvavuN z`@iDJlkQ#e2SEU0aH*aMBYU()i{lnR%;RUlKL#{Kt#Octhz6m?R~e^B%XW>TjKS8_ zB4oOUl?aM%@Mhy)Q{?2U2a2sjNfGSnH7X!G^Ld}}zfcyixdihBix;n4-<`~-;+ zUBd@wFPL)WhoAWDvM&Wr*%LHfs+Tho{MlPA$#k2Vza<;vl&oz7uLGxraZ*aT#vD~t6zVY&96OR_1$|&6sGBOKKl5-;n}l)`PzQo6%L`LUHG=^wWsPWuWO(+ zm#^<}x=U_1j&B2roOevq=db__wNg? zrS~qpKj_+!Lal`}w$>d}P+dea5=!sfE}Vw=J}*)|15U;`wV6@cBufrFL-At}tpH9w zb7pqn)EK8!+i=I_JepK*0g0d-h84KSDNuMZ-bVy34tw8QWj))V&|O+P)M$*8b)MA= zzW%**CX|^d+S#2f4xCEv=P6dj5*8QMZ-XU`l^A=Jt-bRCoT8`dg%BK|urN-(6$)r8 zJu#5yVGW@!AT~PEERMvr&$?1ySuS_<@7$z%*-QS;0@PtyyRDFSU=wQX18uFdpBDxt zW{~2rb?8i>X#0I^WqNLS_c-+xq&8EG;6T%o(iEt{f>6S(*)pLIqqcLd9qbLW4T5ff zYmV*^RP_g&&2gHjJylPq*p|h?^ z;Cv0vDcbugM49`FumA}gaa}MOT4bbJ-NdR+Hk(gUUu%P8yZ?Hz%E5lQ3J%N-IM~<) z2Ton8R~fu$)GE&WTN>-u&sj~vm8_{Xpc+UX!m*nIa+z7xi5eqQNW|o+dOj)u4L0D} zG_?qo*u16fdJMMSlMm}wV5r788LOdCm!ZHmAFeV~rNn_eBuWf~5ME)NB5ja&3NR+y zjk#(Mmu$f4>gh}7V!xuyc1;=z+aH8{MZihoO#;K~3^A&gu zwn*jrN;%Alm%A}H_YKSE zAJ1`GKa`GqVfFfPN<$*lx2Z+h?SJyxzxUy{UnbRaAX9Utlvf7eq9Dm6roi*( zf5e9${$JSdKj6iSKj!+={~KcfB0=50{=~n}G2`U1@2>!#7K`4#{}M*A04EVyq=K)? z_0rDYXw7i~VP~Am;&HkwRd1Q&H1zMiznSkmF2`GYPjP_%MymH_`-QifZJ`}|oZ1$= zvpaf$b3pt-Z4XTG87CG!9he4_7nG&#?Z592ZGT8um##W?@@{{R*40}Jxs@>HacZH* z>L4q0Bl+Y~y`j|3Sm{yG-V=-ads^o+1B+m={k#8`D3pxW$|#W`ntZ9nVgqQ@9uDDk zrad=RDMxZZs#;oMSR%Ts7lf%A(2%C>3z14N#tDo3E)sg@rgiF%Pnjv}j((sf)oV8~ zao_}SzT5QzZavv&+{D2O@5VH^5!jAn^X8abqs`DsHoV3_k2WU7lct_;%`{I7}7wW&s9?cPM|d|$I*ua0~8f!!lbXCMG(70{fkG+ z7qQ5QCUp!pdDuT=iKLd`MVVLV!)()QS_FO(_b_@_-_pyJqG|(x9hlaB{n`qjC3XN{ z$&)Ozr*yfFQkbY>%$;5PM+1Ak@sWz{dk?*kz<#)7P7_Ub3k$;s7HCo3|78qh@B%M( zN!C_Z1k_Xb%(GXURI+Aty8MQp!Yl!M|dVh8D=v&pC)4PLIaIPxs+c{5EQK>|e$up)FeYi@TxQDE3I(BUs@VAhg zK?V+=t+;u1#!4q5#btN)2^+~oKc51~>_A8sKVlRgB(2t{t1(#GA!@+My+cI?tc_Jj zIg+SItUQ+!sz$U120yp^8#_ir$UJ@PU2;f-07D$?e(j8{mfU@Ng3EWs)~6r_jsnDx zp&HXW>H*bgYtX zFMiD5{NVr2XP^DQ(3*+KfWhZa|9i@j->1p9j#KsO>@&%n{#_WS<$2q~AXtJrdicxrquBqC);lWCeNS$5vrBV=6yn3Q>M?@ zPJeCt5sy4aU*c0LM_#iKgsN?B)a}&5R|n{}O~lR-dRsoZghT8*IJ=v1%Kkoy^@)Av z{`%(wr+T#C@CG=&+5Qe&&25@&eK_1=oIET*Y^ZMsHLa}kV(_n5k-zcI z&8;|ca4CfnYeB|qc<^IR&b`B{J}g*3B)h@a|L(<&)ejALSRtjwLJvxxRpJtaDx}gv zoq-UTbVF*MClTf}_We(45AX&Cg7(01M{QP=O~Z=na-|Z4n{p2* zj{(shv+Z%l4U`rv1<@hqRFg~iu%gqw8GVfqx*w?zsr4p8QS)_(LiTH~&AVBK zqB`r?0Hw5UwjHy<8ze0pA_oJyi}x#7!$YlWE_Go`+qHu#nZS%CyS4R_rMgp1T&`4j z@|}OjyWjlRv@W&O&>I<2ZJiI!oc5VkB5g*e6;93LhO^A5&$9A#O@gtS8Vu;E0kM^i zNUaOwqzh{%T6!MH)mrR$SZmMtB2^2M!S_3weSm~p`L3`uH&bQx3J;*?S zJVs_c0ZaxgViEeq(*h%Q&D$3dOU-n4bFLG~qt?OY!_DL5M@4*;M3q2^kYoi}DTm0a zP6R5!Bjcqv=i0Fmq?lCCW{=smn}T)^rPgBpF`wf!<~@QqD;BZPj6y7lL_wnRf)it$ zYA_e0D0>O$5Riu_%;U-$KLGkpvg;P)fsbDh@p)VV$-**XSe~zm*?_T^J=MXI zNjQxG8r9aVF-{Jg+Mv(4%u!Uq0HDAs-3Cr2SHAe@8qwLpA;e~$T^+JDU}RW4PAM?d z8FZ2Ai7HXtcg0K+$aQ%pOnS`JSE|B$_cxpkCbvp=umhzU?@shoJ%U|oQ99!!K^apt zkfh4Z;W-*CfFejFv~Y+n)e8vbamwWynpE$Df6e|UKLFt5OgMYEW~%?14}bK>>~Avn z@BjO}_s#zU!+4*PuX*~#|7Y3J&NwY>N}239ix0oOn{l!~|2*KNRk?ZL!0F<3;FN}d z)OV;w+3!E-HA36+^wm~oJ0Z-AO0u2{r3NoZ+_!{&vyOJav1Ic zPOk(?)T80F_TA=NzyI3nUuB%awZHCmV8`un2tU?$GES|5ya1=e_0RV?b*Wx_!#KU! z{*K#S9;d}KZpG5*zjJ5>zjzWA)|HRNhU1nfq&js|eXqJ`H(D_4b5~VZ%~sg&JlG>>OS&ul+Y~Pnqnb2RykKn1 zS7}k=rBGvVFjw6dV+@m(fEmk_5DvpKFw;7&EmcpwFgPl1W$9Skc`Y723qtS+XC4rRrHHSpDnhZ>aKz%%-+enKYuVM*^Lm2!Vd2^-uJvdfB?>35| z0VfH8kc1SCm2YgTVjX#P8My@_2{{N+3rQV`5lRBs=5e>mUh)ZDO@a zgiT^!j)2pL*NA2c!HW7^nMyVJWek*RQtK2gphF4l<7hrEsYHYRl9u){p3 z(bt;-F$ll+mt>|uUXaFnK`OS^~Nx8GHjtLFRwr6&!7J(qQ*G& zIC3whO{%vwDQdn(FTMk5jjXp^#rN3{Z5RAE`CoCl z{#_2~ZQ}a<3p=e0P`Xy~;R+yQO;C7^kwm_46ehV%LW`e>LM2S)W=B@^u)e zC2*nvr`JK*-}mheaQY>0O{&-YICA886fa)e+@QUL9tcrGuiee`8;o%p%GBAHW#&aI zFzhv!uT(ooK_HU5XJC0}?9XDIc?&Xd9;<^R``?475Dob_9HJE~ZFu7X)Ov9$7Ll!D zGfGnR5?KK$J$ia>vNe0-4vO$jVK2##BxQ|VvkJ7jR8Ke#1^^`%lNhQPa1sIsT_b3h z>&@fRok}iYGii?bU}9|&uO`8=aEK;Xx>?!HY@4qwqysD3*0Y`4-LNKTbeEITQ}vK8 zJqxPVB~(k;YUzI2yZJ$@CCyP?a%Z5RxVI>2A?6AMrWBoFbSA?=d33FNrFNh!VFA#J zQhWt9m>qf%9EfEBN2#%!!Pnr?vXY~}H@}29sJA&eN5H9!4$@nAiTOL4#0-KN=~+S_ ziq4jfC~bi3Qk)y0v2OJu_L9Cv+d@-38IR!CW%D?>(I21`5L-z-2WkB#k1WL ztn(an@#-}&S7n)X6@7+Rl|YeT08%V+-lTff;cha}pjJ>OKQ5s*Z=hdk{`sL6Qq>Mr z8r#+%MGZ)Lvmlh&y*5Hoy9OmFQ4#~Or|Px)NvxGw&3BW%88kRMy2O|pkZgAWT*_vD z4US{2BOh!~mp2mZeo@3m5;Uo6sPu3MyN0X@lv`+u?Q~x=Ei$_?PN3u=klE1Yw^amj z39c~^ff(KEp~g7btxlNoj7Tu49?q^35ILS>WngwFgRz4WNyP?dk2)LUVe~K9^SFlkZL6xL%eX`}R z{>eY)lega{1bxlp)b?WtN?1p>@0}wlu=67G`uW7}aw1SDDcQ01<+HDW<8X-NvQt60 z30oWQ5ekt=2^hGlmax|tr=4|-NVF(*I|UcA=C|HG=lypUwxVr~akAupn`>rjaIrBW zKA2e2$ivks4_5bC0oV1~?iUh~c-!M-;Sk0+)jCm6-+^!b0sQX&hW$JL8Bf3Wem!V38H`du#0|0w{Ueg6M8w&)J2p3aS-kXwwC+`%~2a(n3Pt6OKA z&c|D?Z`X zapd(#s<-+@q03f z>gTI;|B8ysPb3fsY`alEpyF~g!E)9FGhx?Oj6h%shp1xz);?!R)e~AcMDs6M2Uw75 zDT1+hqFA&dFzbk_bRWo+R^E*@uAxf`)e7LKEJbH~%`h@~O3}`xj3?!qHupyrRt-3f zE1;$7`9rRsYb(lP^Ry8xp1oQJw);D3p}NN)s=mgiM6v-J5hjt-zW%2+BXXWb9C6CfSSeKBJelaXrcPfj=$(Oma2(hof#&S}j_QrNFb^)(Ykn*c4HoJl zi>d-&(M?90B=xymsJLXgF=|R8qak)5REU8vxQC~P&LA3q8-16eO+KhQcPS z_{SH&!s%v%XkiG6a7P@uFruYJa2wmBs>}zwW>+VPd45Jr!pYe=u;!B=zU=#T|Nb8` z4EHGcn(ONy+&KWZ&P}RkGn~47>`unX6KlVOaXJQ0cWvuapV>G+p_Iygf7|Eua|hsx zzz|TGs6`1fa6Ay(e&^1Ydi%)!aS-9<=X-wiZ$IP5|Mmr7_l;xeU{AbDuS)f9f43MG z>D}?Bm{hOkSEPFF_m3E-JLAaf5#!W=)795toO-I>8>!x#?eDlPz{y#K)B2S|^k|+IFrPIvh!%6-u0La(+V8eh zJwSs4dr$Zin8RRzh=B$Jtj1Gc6N_i9N;KzHbyf;NG*ZNUQZC1gRG=_8a8UIgxfn|n zdgZ+&bE*i0?}^6Tf;D1LR9E(ml`hXr zwWaFWy+WOF5-lEw-d0JIxV49<9}j<@915WUr?AG6iU&Seqe-#>Cr#qBWlc`lq;iQ! z(BS?oKX`WgqDc;MSznvQq#gy{{$9}D?afryv~veRg=!O)iJrV^AooaiD1j1}b?gV# z{tYNYTmXG+V}M-!jcf}^i-XXg%GPHF(nnn#u3_tqGcHbfu?2qZSMkmLb@7EYkx z(wU&ey8F0iP6DXShHBSW@ZD&@Nwtv0*l|Hw)!6{2DwcKV>mm;XRfd@RvmjKz@1xu_ zIePn!V)5Z2bQdXL%mXb|O#Kt0MfwW@Q3%PeiyFI!Sb}xntNYDN(!DU#33z(?P15iU zN`2(X-HWU=#^}#9WBoxHT664pXe%&|{#+)qQX$WkeT5%hNA`1N6)R7+)-c+|Et$cN zc|2hEG$rZGeIG2pizXwToIy?g+^c?_>dwC7>JH#kdg2-o2bz4FAm}<#&Tbg*JwxKi zf3o?UKMXH;H*WdQzV#pS{`vd7clJKvl~ld;sr@}4R_1fMw8DJy&m2~XG(@KP3jppv zc?Usw`r%cd`4hsx$;q$U>!zni18|RkQ?@k8;4_@sb$E+$YBRLzS9_dpUi!#{JN!*x zlC;$(5$ZeSLt#360xV#l$B}=DR4)Pyg5r|EBM{TRQatjrA8#f}b>I|)m!H}3Jlrho z(lKlFYU16ON%e-|9su+F?AFf}XPol-m1EFS_4X8R?A|q0xqF<#(1BB)N@wN1YW?K3fSW(=<0T6guM?NR? zqQ{=Yo~qYDfxWgB$BIxi^iDq-dPllFfLf~FSeAmjd7OYQ9}HfZYX6r7IDwe{o#sBm zJTv|Pc7*~`n-Lz&6L9pvaX@yOE#F*EHXV4e^a^4+l_XjvJy1&sQUV`tUc% zA)z$+REvW*KUENCoD^y>&=YEPqrEW()gQ3cnTS{oH~~yUJ2&><+NFBdSueCSHGdfR zNo+o&Hq*%@cb>?|67y{D2M$u5c@o<K5_(*13{A?b9IlCpGRrUhU(`f(5{fwj+YmGwMmlP>r+*Y!7wDyWwW9-2st&c zm>(BKsL_s31A0zY8}laSVX0k4qrN6an)Gsz###t-@FcxHJ3vU9y-CrId}GJj-x_P; zz)36)17Kop-Sq&WNhKYO*AQW}>r>Q@Rg>z)2IyVtX_3+k7__g^ig1@=HF>Pd_`J1Y z$2ls47(>wxQEANy52;XT19;urL-0V7hDDpl$+nUbL!FKBi&oGEBGiTHO38yG{5on0 zgmVe5ZYercwblD#<+H=8fhSVMy zU{bx>V!$bwRL_oS@$(gDQzoQPiOJTXs4)1x?xndMo9`|VC0aOyn%4ylwzjJQIrIBu z2+@XT0}>)>a7JF^Ew))?)t_yml`I0myY&^W&d!P9A;?HPlIq#lPqfz07+gyK3gcu; zT^U9jIIJmhG8o|cWGejd%I>4zduz?82Si{WHdL2%S+ZVqKV{`@|BlywtPgt3IN38X zRbw{N7#Z$Je9O*8m{e~BN&TTLQP9l}i5cRGM`_|aYJ*sZL3y%$!gf6CG1`rBT5Xdt zFS=#EhMEsZFdz?f-^)Bb1>o%B38xR%XjMM>@xnR{!vg@O`RM|N{Mn;bkHQ4p<8&9} zW$+=z=7$}v8d|d5M_IG zPp8M9qf4ZExYOg*!Xaz`@3{GTKBvxNy86jM+1YQK+N8Kk0zHZ)jR0fKv454iR!HY1aQVleV=7v7p7rk4t5rI?vdJ-D@2Ol zxJ)K>vfrCrXV?%BK0MuWJ*+#6SG*XFYK1BaAsC2IggLZCyxf6PGd)}P-PXjm3dy^) zQ#?MmOTi!9ms7~SvlqO}-P{jFY6nQ6A#&VjqS3=iq~{ED#;JQzq#NzqtD|(z6%ghy z_X347^!Ev#beLPAPoT%6~ygkUA^NMZp_E%YE(yYA;WEK)sRLJQ+0BtJGq zqO%ns9!R2M9w(b+0U5e6u5(gCN*noV5D|15mb6uO6*e6avU5;5X>JIEHWEF zTZ)bVV(Dt;acS!?x}VXRt)SL0Y4^)oKqA@u0Ku<8QJ44iFa>Kq&Aui=OsLFQmYpzW zTl0goWYt28mMGZ1iG#p4Z!f5jwo%EZe2boyjVce zw7)GygxidhdTj=DPgQ?U2d4A&~xf0oFZe0t|TdK#OeP?QX`&*M{6)dp{32 zb;ikc-LJp%-~a6maQY>0wWsPGGfs`su>Xw$DVt_I`*6=1t#F8?lCsIVs+;(mZ%7eO z%(5<^)f&McZmzRu>A1I~yta_FK^(EpS@SNbN{@uD{=lA-nR>@s+!w;a_yBznXwB|* zS$?MA8gyaQ<+ZKLZg@z2aBXmplka!%fxT_V>(L+8Vr=~lsI@X>D`;wLo&yU~5cfEh zC=^M(1CvTdRFC9vi`1zdr=T7V(d353jIeVYI7B!M$-OO=O}Vj>M66`4A#ifogDP`c z5frXR7p}B$jUEoMWUL)a_1gRuMIAlbcj~jg+^oJSLdbUT=fTT(d-nSrCp)hqg}olE z_)>!jEe^uw3RN0FX;QVeT8{WB8u3{pF86Vtov$~JR$y#E9xFn# zgx*o67p@a&HIu|1G*yT0tFvp%8xP%U)j*xXk)!3<;{*+`wFE*lq>FfDyxM?KSp0<5 z@mwsyQxS!dl7m`fXVv|ESv;hr+Bvc_)Zi15W?A`yX>7p)z^9XyUn6Z?K$FTrQairV?vc_YaL!m9-8iC8 zo7O1K2>bd7g@%Mmgq0L)fMC9af(2m=zW%b<;NAwrTNLV~|DM<|*a!@2YJuRP z8o|>6gH$A$cPEL&-3Cs9xiL-^La|}KF_}~-R7id&*i)Iq&~_RP z#x}{3y!-`kQ59C#PhHwc2TmneN@<9Z5RIX$B^mqKuJ5=)#Ig@XmHf|gJ^%p#07*na zR2%~}_-G0OWwUmFn;>^EPJRPn2=3JrVQi7)UVz?zvZA^SP=~~s11Cfnhk>`ZfjUnP zoM0a}R10M%Z=Uk;yFcJ^ZGyUsa?=^7DllXBn$ep{RUu|8TE84PIpY)~goMTossd$3 zV(7q$=s^bk_Zx6pAF)A8vA?|-5#3TR16pUo$Off{*x`M?LeLiPk+`} zt^2-@J1QQz?Z8QkrRWKC#;Jj-W8Y1Pf$f<+siu9olW}VEo7N}8ohfl`+nhOQ*c)() z@n^ie{I?4$6Q6fA(5qV%L5F}c-67ReI8^jtYvkqUJ3jl#<*nB@#wkCaZvA}T-N85= z%~)z623}{JQaVS14Jgm~g}r~iw4_4WAjB>~?C;?L5xMUC?_bS00bkqaRA2Qt)h{`i ze~-5}!0DH~z0NotLl^vK=10(~ohi_0<=uLksUdK)+4ww&Rs`Cn8cJ^8 zE-mr`O>T8S7AK0@&ibF0nNAH{9ebR5Y;P}SeSg$u#~d?Gc*2}{Mr@vvaC=~`F){Yb{a^Qzw7pzJKeY-m#4caaqU;Y7%Hj(OB{S^zNV`!7?@rbVDva6m|2Yj_0MXf& zCYg!;^BN2|r8@T_>naM@D|_uWUpqi>&{>5_WV_!1${g236|Tl)Y=wPdKNhhnHV?@X zu3A)jk>pH+dmJ#SjLBHM+YfB2r5*xI$&-})9CpS@m3`Xrquq~Cwa+v^gY@&*BGI8G zvw6|0)=_RA4s&UUry*|g}K+74Q z)q(Fm{vpGe-T1W*Rw#sJ^_k$!8A++#6Sst;XlK-#FwCOin`dk`5u|AM5w;Gzc=Mv2 zyHuqYvN=X_uxm&f<5Zg<&90B&yg~>Tl98IEmF7LECL>ctLNU1@tx0m^aZ>e=j$k1j zY9MIL^f_R)g}{iIr^H{kT!Ae#L?|IG0WkzbXB1(5dBuKr!{Ene_JSeS!ra0=g3WM} z;ss}W7oWvt_lO3d?fjHb5hf5g$lA_TfJM+{ASVy0uisSdela^ZPXuR#)f2=T7C@sRaV$e7YG2;5+I>TVG9+VI z18t3f3_g_DzxPZsU?L8j1eyoQnjJpJ$=NEz<*$MPr>X>5BlU(=$%u1hcJ(P5l(}82 zX>j&RQE7vug*lF$VWk#kak;YKX{3IR-M=SdGGmIhH`1^-{HP5$MGh!ah<-nTmbMxi zJ0kE*-lAwAr6ZXPV19_T4&~Lvbody4L&dGm~m>~7ocX3cfTW5?|1+%ES|Uh&za@a2KTo2{D%jd-TSpr~ zT0vx|Vm-tz@#x)olkg`5T%G)e7A{gw*!1dPi?8mKFpKZki{{i=k9o0ixZDwcLjNVZ;J|3^--b zYVsc+E@?As>`j}esy%F5(FI~d3&s9HYvC{(8?@i9sWBq8a{lxqPG4TyJ|#;L6E7;e z$H|SccY2)E3!`qFu9ng#!gY+?tVe{(NxAk;veV^iK<#w5w*ZP^4H7sc51p4*tT)rP zHp++Kz)97@Kg>(h3R=31PgJ}AVp9Tx-_xdK3>eN#l_QUnN}+frm^c(`MXLE87T^@? zVi>oBzobs7r+=B6#zH+>DQWAoons}o;hqR+pvdt6T$20fbXDX2G4Ad1PZRHPT|K`Ucf zj^)Bsi-(I?gQHzj(#|uG+Yn0Zff?#dArfjOl4x>~DYOXe!rbI4;vz?-vt;%?gRc=| zv)fNqD>+t@L&{m2{3f{P%t3IJUd%^@!J-^GaEd-34ZmMCe_ms71J(>Mpy}|TuW7ne zuQd)zgz?DZWJ}-WvR*`FZ;rI37OOQ6f~a2?%6y?r=aGCGi4_JdR8fXuL{lV*kjQpV z9w(GQ!u)o78IYVoB2)2pgS4O#I&f0S#5f@#_mn{qlLQA@Af?BAm3B)f=&?LgS72M0kdktr^KqQn(6#;I1jW}>ghl!!sPWHdx2 z*JZ8782fi#xkqtUhN{NcT6%-RJ*RpHnUdoMLd`^d*c_>5S9s$MbjqF8m@=z1xh_Q33c5 zW_tsieu-OSn}7~Lwu2Qp3har@7=XHWbAzh#Y;F4QaCwE6!g?~f(95$EFX+Yn4K0Ac z`u>W^hg8L9Oj@b6zp)!t_c$HTPw)p;6VW(g!3vaC7>LgaGEiX*h4$C`JN1WK(k9hw z55g8(Zbf15_Pd&;6_2PDr?o~t3h=k9*$Ue>3&nw;*W`fRdsAq`6f0Vl-C;6m+7Nj8 z;1LoAM1?fF7bZmJ2AmYeV!$c4;gBe2^<4%{1|HlmBHFsGZdRV{+}=dtW;G%xC;7_0 zrAvGe&=}b6n^bRY9sSlNW&wjHzpFI4Ndr!(72@g=&jx^!`<;xbv-jDQz~B$09EExW zQmcCxqMApoNO519QamBc_QK2e&Nwxlbb}v_Ewi75b}pM#uQN`|t;bgA!Z^M2`4_BT zzUarm0v`-$r(&L+MVe>dZH~bT0>nKU#(0MH+!vHFn+~kC`2Zb=h%Wx51{qtS7J9r2 zIS4HrV$jK&4YI7^_8!}E#X~+sJpdq9pTQ>Pmn$N~YTkvd?il5g9E2K*2fW#J7ctpX z)R`tHl*+9+PKb%p?95rZnqNKyY#?AHx6Ym>>@r6ZQaNbOR+RwTxwRK51V zG;RBYjdxQ9Spk)q(mjEx7N&T_!g*|b>ww#Pw_~Rr0Ehz}W1NmWPJZFE;j!W@Qulgj zVM89|5XcznA3`*PK0?#rI5aOhRy{o z&Bqp)+x1!%$tGKT5GT(307WFwbRfuva7dJV zKnIt7iLgFNOmmazJ?vm+Sj7(TuAbX|4bA6Np4sUuB#&C`v6~4xH-I09>%>c`)Ggs(0&n>)x#4O*q7x?eDPFqZFR@Fxrl0 zvMvE8BA3_={@j7n^HpS+4h%0|qK5;UgX#Y-PtH0Mf-E53I^c~GwTGjrN-EUC?&bx0 z1WrU-3D8LDhD4+n@JevT$-N-#mnYR!XG z`~eq1g+JaXKiJG%#R{SJA{fI*?hUb@rO;xKm0An?*^0&Nj7J^U>@FVm7~MP=8-O!5 zX||5 zEiJC}pa&};+Gi|)09odqL@fq>kKJ3Ux+d%kNDMB3Qv^mK9Nu>xz3c9DCPjB z0jI&4H9Kim9Jc)qX3)ZX^Ii|SlXt4T1)(X7>ew$C10JX{?i{0WN^G zx(WU9;S=8GBTnSnS8}v-f=7CLymHdaNxk7he##-3dnIU#dhY_ZKIf*fh{oR7gRA+V6yd>HfCqLe*j75E*wI3dDW>}L!89IyWz^|C;KF733Wi$fWj;ksutWYWJ znLAjrq(>iID-~i3YiUg*aTy&wRK&RnKQD!-Gax-2!kpr=Fd#xtHH_8RGDVp~W1MWJ zn9$g@;Fp&JK>HUf#H)M%#P>v97TFnH3sxB@o>*uHuj%xY8e5V>vG?=_QLNUKiQag! z=?ur;hoImIBIbp90uILMTX9&myEV>2(({Y?fP!Ou&50;%?-@S8FR3(ofIP5 zyrYSqO*(08U2#v;I3(IUG?i$8ON7ICH2=kmZTb9~@x^m?bEeJ>j0V46Z5EvrXGdKo zUe)erD@{~j*Q9z_V<{ZZUlV&?%p?x$GurqA(MpQRiaFCl8Pf((Mn>KCdkE_-Jvd)0 zMTL@ly^kZwQ_2J(243+v#r|wUv|bx7`;Z_2huw7jsH89V6_I`6%Z4x1d#oy$>sBLHWjoG?-X25A|$$Dyqy-o$q zbzz*M5Sqv7XaMi=mR8xKxpnC5Qrq%ex+Lz)W;h*h&F8c`^6TucW<(znVqls+zw>ob zfFuaB?WZnGXU>XT8{>3(f5rNA;G4g0-}|S3@dbySouikYrgwUOMNEOy`zv5%+TYDM z*>U;m!M{s#;ccm2N?#(?i))L1$LC^w4XNI0J0L-*xiTNVJd(TvK2Iim6G#4L`-QfW z{U#e)KU>%gvDrRQv7%T+xwpFpt=tU3Vzi||nOS?z{>!sdFZjHmkXH5u+RO&)LN5b8 z0s2f6_eI1Syo$mL-lJOArFyDOZsrf>V3LiY*n^}?(YzRMAV$>WC}H_@M5-q)*?(j8 z@>NXc7sMl#)rNm&7509eUAtUSj@YZ?&Z(*pgZqEfZn(S2-akj%vs7W;obm5|?N|B! z_Xe&{S7eD+*eQ&~y4Sf&_58mClINp4W-*3MY~EGO86~g_fg1--C;7^B{!MnJKrr9Y z>F$!Cfu|>12n|xUPW*AIp8rJLU!*S86UebKDn1a>i|hsn*41*fVlkGiMhmp98a#W= z(-NyvoW&3~=C=1OQf@^Fi7xb~%)9LyR!RwNQMyR0=(MVX`hZ}b#QsC~F|16_(hm80K- zK@WYMw4u|DCk_-+wQI2kKi1V|tp#TU+68WDeZ~k4Ee_bfS7V&)+Hn6IHl(_BLEGi6^c58z#&*SUNOUcNuvke2pU|fSCuha zB=NP^5Xm?uaNrbZO@iv-HVeBLnp7{eIZA*OqDuEwmLW1?jME}#wf$%wr#a;1zA1}G zENENb?zf5%#KIwxnxFC}S?tGI-I@ATZTKxBByGn=2sHx(x!tJST~)n#(}q7|-?KXS z4?0q#fzc?Dv19@nQEO_6Rt{LoD5AvCfRll(heIrmPiv%P753W)wjP{DPAO4p#=LhR<3vt{ zOA61%${Z{ELE(H2A^N@8B;bb=JFj^&lH##ckJlKdcGDU{A34ot)qs-~+FB-TmY5|1 zZchgO(LZ~e@BP6O(lDT6^Uy>LIJM@1cpBVZA{tC0d_7t>V=Z#nv%j*4 z>$S5FJyCDC4V+Hy+xNVFW(-P`l4W^H*d&_^^>k;9Q=v=sv}*UC9nWzBP@Ndp31Q^= z`Qg^TwP1*GlSp^OwZFPGpVM*B!51H0BYL0JN%~T$UJ&td0zL+#EWl}gX$pn3jy<~j z$+u0iSLVu(|Ltd}DldF~)A?HlwomS@K}V*2zMZOf#5nzYsh%@>(-+2s=1YIA(R5|L zeNIEz*gBBCt+Dv(vDVk5dLhUXN&Xc95%rb%Q*RijH`_0?HL0EiPjC`pom$c4U01Qf zY%GP7gIzQ)*Jcck*?dp?RphW*`&<@scq&AfF?7im&s8(Pv9ECVdPyrq*KxUpBw z_YrDijD#G_c-vyrLt`ggp4HO#Kp8amE}=TJ(hT$};_eX#jx@%}2VmC7)E}R46&D|Y zJ=AeVX8HapBsVcAS}VKB=QVjv6g@R7CcM4k|WSxVe5( z$w%weikdbr2bVo*a8}Vl-?B!vzfQ!!p!vmSR{Da~P36hY6s;z~qe=C&Qi3rkHB1DT zmDDi!`SA#Q2^O{M9-!h9yP)b!$Re$?veE&j%cIm;FzJbsP1fepgmUm0^(7Wqy-m=9 z2hPHk?|Vebjw;F&1N%rXQlILEpXeDmL^M`HZO60ioe)?UnzlHiU)hm8iZYR?1T<6! z7!ah8e2ugi?4h>7zV`VhA9GiX1WJg`I60^6g})^NT6$hZkQO1>09N=?pgI*TL-srw+8rib8W=#Ys%i|Y`_?rk(CCpiF??gQK$?A#VnZhR7VKu8*V zP1yNF8&@k`s%PsxIOtq_5-PQ)W}@b&TU7(Kic9$HhSjBdvt(ZhE(i4c%%&a)!59`1 zh_M}CNNNEP&!S0F&va+^vnmz<;^INSogu|%7ZvgMYo0)HFlTG9+SNhUips!H11ISj z7B7+r8CE*chENAB%$_nAs1Ooe@Ea19$bS88>Z$KY`=(`f^#LZ6(?Xext=`mtG)N5; zIbxiuJ!#e&oo#76D;7uI0$1=R8G%xTdDw7BtNv_DF;dk4X2=Dit@-Pic{XMaLCI0g z=Of9Vf6APo#2F0%34=@ZtX&meN!2?Jhe%?~Bfw^5`*`V$lRD#6oN-Db+nxO5h-g2J!dv6>H6G8~`JBKOP;(S}NiArEC*Gxy3k{++X7cM2Pj$ z87Bj7222VXe+IZr4?1wtSAf$djX-3M2X3xj0LO`X2Ap1HoK77$T|Gabs!Ot7-4P%8 zHT21iGfpNWk?;!R^a^mQ)qoQ^aQVgl*1s(>y|4B+wQYTNJ0Wg=HM6^%2=ai<=}5`f zmu00EjmM+7vMB`y!hr~?DrN4!gqe>EkYDtxMc70sqK3MPN(-)h^#1cWjfp} z-}i`d(mto_?lq9o#jRw$Tnspkg9E30n<0wPC7T>f%K4gSY++j)aDt!jb5dRAa>cPR zPIvz5-|OuSaQY=~r30tnz^TpbXq|b#xSTz@cXI;@mm5ntinFD$y*L>$$l=veml>JI zsdI+R(~4#oikgGu8SdtB4IX9I|yR(^0p&KLD`@pZPk} zi|ZCJ(K-*ZFj*2hm~4`m?7*pQ*RkC4LV5eqAF#%xr0DZ|+@Cf1^<2dEuge>K&XA}9 zr{E8gvCJqNN*EYw^xrqBTJj;K;!Kc+#yC}HoP^79Kt&j8W>xq0`^`A+;Gs(3{^e7G z3SXS8(NMhuZpBy&)(EQXYvdB)lba``Qe4&B;AwyD#HNy$LRLXFby+5ALl&!hoSOKngZ93@>E}4kES6oZt8ZR(18XMN6RKMBm0&UBR_l79+}S5}cE{I~ z?Unzzb;pAj{03D-OsXd;9)=Qn(Yj{u1#Pr224|eAn5;-^ArtvrH{=j)_$^}BSf6c0 z->0^gRg^^VYiTAU#ymQ}6yM{BIvAi|zeBCGQnbxUt6q>=xP*8^LHk*Xex9>LsKtPj zMgyOoz%_&wmC8gm&l!zrp+O-uS#hlOs2KGHQyj>2;3SHMO2CpZXBj;{-Xxb%Sy*%r zwb*zl!C@6UgB1vj4t7hj)=aJ~Dqa1-?MNI(LE=Paf(>eq|I?E zp)5B&gj9_=AL?wyYCA{4E&!7g7K&JqL87u!yN3j|=R!p+C9z!&wSo*ij=UdF|8olz zss0}WKZ#AAxmZ8Nd_E(gV6s!(Z>Tl{3m^tXQnKTtfS8x({Gz4OadiLA{yc#(WrA2D znrNUn6B0Zb)Bv~p-KeMr)&||!hjuRkJRG975fEaHp1B%Wd%3xX0ykmJFj$J4AU5wU z1WHY4O61T6NBi?ehW^Z$gK|B(q&5VG5V}VrMxh+7)fkuXrXWi4hRVi^z^i@s$n1r2 ziXm`Z;}1uS6QZb(p|ECzsW%Q{tWXfx%{NdBr{p8adnJmkQ>l=2{L)|uJMPAi4CB@q zClyQ96CsucoSboL9-@%DOwa!AZ}tjsS_KdW4su}Up6T`JK&_eC)8_{F*tBhXHWFf> z%$42cd@ET`?;F6#pYJGp2XxMQd==wV>w$3{;VT%YuOriI`ve5$1+1~*AKn1`5?G14HC2lphDDvRkK8B1S*vV2s~&( z7Ku*lOO7tlX`f;40y+9f@9YEg^3EPGbB#P5rf@6UvIL~qP|;X2s90(n)*VrQ|Dk$eF8=;K9K!ua0#~Em{7$Fq{@UhoatuM0 z$i?MTLKSx7z&>L7V*gIH4aIX~Ia0YP8%w8ZY=UU-x<@Sz&cf0DLQ*UFlP5V&t})KE zqQX2WL6upX=ffE%e;`z%G)mEbYo-Ao|cyVmqe>)m&&?{o8ivWjB z;MpS^0DAU(?^RSakCV&4D&|`Yr6A0flBmHLC+ZT`5j;Ik+k70C>6Acr_jB3 zjUBT&PEGvQ)>xvjQ3Jz^0M&qps&c^6$dVM2t~m)8CbNpx%usTd1*!^Dv|x}>8_%?a zQbd{C!uF-39(Z7K#4L@)1&#n$kYbWjq07<6T505j&FraESr{jkKx&0+`+PN_R|ziF z!`N93Lai1non!>56fNwJqt>pNp~C7I*E8ElSj6=ST!;jJarUn5fGL$0oB911i!PC+ohJ z&NwaJsSR_#MndpGtq$-b*jzAR9#?GZL?GF5lL85pNJ5Alu1Ry)5aHP1fkLTudyzpIpp z4%SeyXHbGF6m5*R-4j-dgN9}8HO5JML(G1sVAt4gIOT8Bw|JWF5tDnI2zE~hfuafV z>#h2;NJP*uI`9*&;*Pw&Vv`Q6Wc7+v@5{p>qL}m?U>u@Hmn&COM$6=klcn^fqmF$_ zi5eoMnifFg8mWo~C4?1KguO(Jzf=zShEiwFnftwU^g;3j8`vHhzS7^6>Q4dKY~QnR z2o*G$*DBU4M9q^E(xwBG5QXi@uPkgsW1NnPUoZw6268xX{oH}m$-q26v&Pm@qF&o1 zNCyTD z^WfbR#_;B!&9`%aZ|Zj1#SZ zwLj-JBSpRNQ+k*K*h9$Rf(@>XQ+4KLF~{%56`#NRm_PsaZ#IiCq0+l@#k(AXCmgjz zt|niyqRorVY6Cv);iIV5KK#~y)gC6&oGJ?&ku{RTa+TeL+8-px163D?2*x-G2HsRD zvn}~9^7A5i@m&c;e7LDX%qB&v?kf=0F5?h|p@wd+GR6s{dz_@t_c=dYb!>;ryJAW1 z0gA+`obD%7gqJAn8c36+pl_{ChdFf)X!VHbs1%Q0kENI_%7>8_|J-2s(-%X@8cUwc*1FD0>~|Hd0qNlo(FUzH2CG$fzV2;MtGX;x zDM9$~JBd6%$gth-5G;&B92BXq^{545qJ(J2SY4dh7Dw?09l+ZvL%lZ1`aLxzij3VZDiWCN)iIIbu<*5~^HV3JSFo#GD z6{#)FvM^2uD*_$3h@+#%I4N))lNZOnjaf z3F3^CR>YaAhy^bm(MA>oL4pn;t(ivC@jAGXAbjU{-|AkXCe!Q3>f+SD z%aK&C&qG@7!CxlTgT+U7v-?|nUEHue->^9w(W*TAczN$G)sw@Q1Vb#tZ;#LIG6eVT zSx(3MEX_Cd1~|Rhevz%mk%vW=mg@ef2yLBDD-ciidxm1Nn#yac+O$BnuTc=Xs_m+DpE~nfl5S*!L|mRzzUc4J`Ds7MZC*o@{;c>q=D*j+j&dA;#%a2H8yIGP_`m?R!@6F8L%}Jt9AKH3=XuanX<*+ZEmT0M0QQiWqRJ{V4Wp+Pp*- zM{W|w=)o>ZWTvw}>^MYwee?p)fRp*140kU=IuA6nA*t<(Y_+pgR4Sty^E+189~l{wnA#T*Pc(L9{94SM!tLySPd)CrL&m9-a@ zw>(Zhc(|?EA+|KaK)qS}{ng}xnnQ0YsRw4P{r++gb$cARd#j9R*JJ^ z>T}kF$LsI%*3Gv`tU62b>h|*LFKxZ+d!!VOqR?=!k9cGXlBnYcb>NA6eSNu(FTY%GT#%Z3vV0i4n=_ml9eRfavyu;%Jusyf1 zitA?vUVr>2pQBYdd${T01z%@t$Mf)o9gp+3Hl#5!j&A|n8A%?2RsH~}*PJ~#L-YY3 z|L`SO&kok8J4p=b?r@6D>Bx6~_c0INJ>{)$p5FSmv->7voc1@J5$uf9t#F7h2Zk-6 zW1gM?kbL;r8_SIgbfh&WyT^%IxW6+W(Tml9i1{V1R}pc)LzTeQ>OC&kM(tL61AnV#8W)bk zArKIcBc}lue>i_||31?&^oPYy9z60cYb&E6RRa`5vG*97+^)$Z8Vu0NcscnT8muU4 z`{P@1)1h_9z4-F(Z6=bt_s8~o!aWMdz7A;;Kp10tz(Y}!RJpB-#vpZ2BG7vEp$`)l zi*1%=P-t!;92nyiCG?sWv81_}n;zZ1+u3wU_nMwe0H^MRx~!_#~ixFpWJXo_+etphuWg)g*!x5#Akv9zBxilR{6 z-vX#wN|=Lmd!~DSnc(GZ^L%*WL?KiI7csbbN!2`iaxi}qP@;Pn?g#d3>%KjD_MCAx zPfm#~m>HMd6;4+laS=Z`0?q-QLI+NY-K;Il!;RJiv?lUl)z@L5nn%SKPFq)^3Y~GP z-lXugCT&qk4@0oyWlYO>xM4UPd^uQA9@H2o5UScatWw=uW5sn;W6P5IdU8pa#g>~< zzewdW&SXs3R-JhRB}pNA3g5!|YQOOZm(JQfC-9OD*JVXgCCkjeyZ9UCSS*MHF<@Lv z2hXz)@*M>OuS}p5Q!>Cjlyd7RmY}_uZ(C}GKnL6v8td*pr_m)?vzRQo9rxgeBuiv9 z+1f2hD8ZP#;^p~3^V7gMoZGsumT%bz4sXE_9Jq^v;TrHpkuJ%EopCbQV6)kTsFoU7 zLdF<5`=+a!NzO7=1PRteiZvqQ*SIR5pKW<(lNdxfDF;xPVzN*T1W_A;8>xg+xjH~D zVk=GBe%e}W+(;2@hLcCrk8@#MC!Vj&XB5IiHhJOrq|W_ZL=o_?3X|O$&l!?m2TDJm z;yzM0A`vt*44$l+2a`nC8Px$T-aP0aT3A(ECzI$R)jRSy2?knK1GzCyo?3P`KIh@? zpCfL154j*iWcTfFFHS}^^}R2>ITnMG zb?KfrkCOzGinU`rSLJNIFiu(ymJH{N({U)7d7Of!>ZL@81Hl7QVi0mGesdvRgVe&l z?g=7nG1>9x&w{ttzrvH7U$Zr~eH}Q}nz_FIApm>6WquX0YaNM@*1a%R1;PTHR^xYX zu?ccCi>qzLC0Xfg|V6P?se9wF-{>#*EPP8>b=>1 zp>1KDTB@E&_4+35QErby6}W#hBML890~&?vjd3LnPkeOo4KCO3@w2zSieM9sxY(|aZzSz(d^o<)^;0h zfwv%*YIbygZ9bnG3?PP&874K&Z?f4q>6bE~l#6fo`a_H)*z`c<|yUH)hXe zHi1fw9uDE(y|I=m9+04RJ_Yk&wfR5xKyE7|f;PF{%HKPK1X8@D4FWdippxX!Wm{Rq zM1s z#YZQf@oY6M5$!TG*AAjEyX%Q=IX${ZV_M#!pEC4E>9kkHg-=a`)Tnw zxnFS^h})hY&Z@OB1*)8{ZC_sOX8!WSr`*gI_OVLw4yj(Ubg|V5$)77VK$Jk0m0z8E zlJ{D6*dI<@hP-hvsI(Gd46gwRfc^fbvU zhk!-acK!UoPrh&a@Xg=2|COnOcWo_M5A4#r|F(U{lun501XN%1IhFYfR`~-eaB=^4 zdGx-4lij5S+~|3_#Xf%BEylI8Wy)Xu(Fc6-;ld87%V-6J}4A}G~$wL>ljCY&~2QuUT_h*WYfG8A=^ ztCexKi5Kua4KP_pKi93zLV5S}|6n_HOb}2Rdsef|S~4?a5@3~{^XvJ~IU6SLQzTMx#xb>&%t%7f z8a@3oaJjd}fwb$vzmFZxYE1}HXQ~4+3;72AQa(0I3bmToOhD>HR7-u85Qrz{aUy3#OT`N@-HPWOI;e zH3_TXbRnxr=;ry14_^EVU)+3~7u!GN#pVxr{P=&tDl2JR@#LTU9`cR*j44pYfoVPP z*4rEA^T+Jg517y1;YC`r4Flt91_F9$iGo6_3!Bd=xU8OFz`5PeveFr+?|<}?AAa&2 zRT#$=4^GBAqu!0E0ya)8x|N$RvJHCN6a zu6gq9bAHjS&2oZ8rq{MF^Eq8#{u==H!?%d(f+ycTUyhq9dN$kw(O-8HN!)vK%CL^) zX~z%$jmZQh2+yDY3v#|<7%rCR_&eVt+>%W;sU9qB+A$!*C8Oa^;N;iC9bpu!uK-TR z5$cVG6=m^I{sY-a-Tv+42lv^n28L32`-{&Il!sq@ z2C96#I$TF625ZnF(!t)!zlPCq?;hflUAM}<`J@F(*OG-ejJN2 z;;>%vayVuEvU2iLxyW`CJ2Y0V$r+U+S%fk+#tC?uF8P`K*owg(Na66PLQB$W^QxN1 zD;6t`cdL!Z#x|D0er~|2F*D6@4`Vs-*8Gx9nOK*@(piy8OFnBM9IMIpax>p>JzR0M zTGJS-=KW~hXQ(__Jtvi7!)rr8L!pGgcwHEZu?W>W%|#sqcsRr`o8WFgEX8l3c0d~x zl-d7mX@>2)UC(EH@bvf48dyzxJAxrL1(~lc1O8X+nA3>VH8!JbM#y$-hR=_@P=c17 zf6wN-^75}*+S`5{x!$gw6{|hv&_Ixx?sFUr2-|_Bu}eyY3|ivSwa?jtNt^?cHZT~N zrFg=d8gL?zao~0o4q;?Mlb#8CG2cdeE>?suI5)OcDzz4pTHN?hBB|Q2*cMbGI#I&j zSYIretSw~~<)gR1!C!y-x40g+7~^D2&8(G3r358QHsBK0M1|9AvcC@=%>8)Bx&Wu3 zg_><1(@v5Ph*d%r4ne5FVyvw|j4qLEtfP7;LuK^AofA6?a8YHb#(G3ra%T0ex}OtY z;Vpcekg+}jx}NqQhklc`!9`4aO#L}%Kndz@$w zZ*kd_OZ8BbWz}{bEE2rMP}jJ`r-Ki`6(z?5B?L;S-Y{_R=)k58{XUuYWEqhtg39=@}RS#4V z%>;o_EwM98Ap83fg&3T1!k&@UK}M}g&5@UfhwP_!xLN-eH|yUbZN5dAX9PI=#2-wyj6r=rS*dz@5Zl+5|b znv3nq0M^kXH>Ko*rlAg7QZU6v5gV{wBr$|FDMA`vvf36VvAFP=iMOZy5=rkKFIm0r zn^7%XU;mJ*%ARkL{1^aeI)UvY7&k~THbo`z^k-LGeLfKMNe3%^YhU6hRj*uIQN4M1 zK}Z3W8&=!I&CTC{T1sGyC$H^W+fMJ9T<_}nt3Icvg!7T=-lont%}XlVmoZK;t~($L zG4P##^5_?m=(TNg#5gs!sck)3@2~);Qf}C}pX_@5TNISlcHsWo_WgB?u(};h|8+MJ zVH`I+dhd+4zI7C5o<8F8^3Oqpx8C|M2wxEn0k>t7O{xd4%k{J>^WNVp+>R=TFK3)! z35a;{>8{UgvezirKFjKuacVW|KcwvqaQb_&sk)pBC6=2-qT-ER0}=KRPkH8aHxWwa z>BT88w>DSfdOTr2tQgD0I==*gtJNuuS%HPoX{%JF6}sZ`n1vy^+StYU_VZ_bE>oNf zkFK5p@bUH$YI&6u_Z_5Sd_?S;aN#DMaFd#$p4Y-5n%5_U$bhhwO@A=8fwB+t=SYH& zPoD5E{?UKT!%sF`9L$$9V-c{u8xPK}Va3}~IK)-BVU|pmi53&wBsdL1RSjLzX2&OT z-;-=UzIUG=Kl%o|-mkniJasRWYJbeDCbxPBQ&g3<(kMDO538@CGrDQ_OPU{{bJMQP@ zni)JLOFSq6J1%N|hG+NBI1Iw&YM@G@&vDX&0r(L8*}i!BN)6T>Q(U_*=CLcjzkc5O znpEZBRkATo*C0ZcmC3q%_Kdg>M*xitEH+Npj%1d=OSY&OmPK+z?#eC~8TAFNYKUr*Hix&+gqPr-7@@IjFis)VlpGdioGENJYbnvyuo>xjZRc zt@Y?WpbK!Sme@B*WR^gQk%#e;pn)u6Mtv+^AH-#Gbe1?vvg-_=Kcfe#-?N75LqyeA zmK47@8uw#=j=nFo18HM@P!kb~R7N-bPhyf!JnGsSHxa27DVES#qR^h#Rc*Zu3Zb@0 z3SkKD&r@UTRlN~{AkH{NG1;>D&ipNcFzN=W-Mf37~@X>#dmd1cu!y!`0+5UayO@UC9>BDPwQ(~@#^=eNH=IN@{eQw^| zQKf^bNM!SH!?1GsP@KjWy+ zu!PINa59nyYn+V31)J$Rgu{L0umznNVb5ZS0jjsI{~KCL5>fiaHe zYnp$;<#f$o&d>RxTv?++Rv-cK4nB73v*(uld5*9UOGEtdp05ga{8Bi`sx4EkJop<60{sA>)9aO#pfg<=vy1R z7GD`$dzUP+1E;X!;k&0u5Z?c-2VWYR@$D5C;K8Mm@15|gzyE|d7Q*Sj2H@iSci3#c@pIqf zm~o0njMK4P@3Ws=@q>T$F*jD~vAK91)zmKuhXA~ zGd}w3=YYkn6Tyi4`! zbj`jLu0+uMf_Qz&PakYZ`7xKPz@LBP8~o_K6_@L`ASSj%-u?6gK2Ia6@N#{|?!`c= zflaV-?&A4p)YUzguL|Qlfb0;hT$Gm#dWK*(tCVI-1Pe-(%(RKTH~*MFUOnOS)nmf^ zlIQXcbqFxSIA^NB)1$73r5l$X9x&8IAiCTpkaaK_n1V<}R`$?~LnNLRVl3Q`&-sJt zkNH=_@A35PKL6u)|8su*`Da{@A9E82UhW<-OoBv34~1d3hrzn?|KkUL#7(^+>ug5x zVltFDWYXbtl&zVkB~s@tFXSE~r)<7?!TDzop(@|_^oq|;_x$ux;M0o-{CD5pkn)~Y z&B#1ark!;MRj7w+O0Ep?l(nv48aSN;+c5IZuCiy%s=!%}6cs)=IcLj5w)q;uicL8| z>w)WG=7W3ZoX<1Qhs0V3E>q&bh9BQQ;nzi2u?I}=|Ka`n9CEN!H3n2%wkMG0fg!@k z#7Ym0rH}|jDg5oD`;4dd&=!Rf0y#dUj1QPoU=}6UYh<@#+!anF^B;Wp0T+iEC33wz z=dciYhXyt9Jtfkc#p&7+Y-teNzKk)i>ikkiV>sCvhIb-ic5 zS+h?AIV3JuBQ@Bu`$7iR?m?T9@ZrUVaK53eAMj#zN)D9~m^E-&R)l0SI(1oN^$`HO zFmjVtTvJf4nPksFV2Z|~tx9By19PfeN#^YG1&kvj-{RTHiZ!SF@$jqst4F`ju8gE< zhS_|Jk;+8jCMYjf35_Ev!3*|GONG;r`Sf0)YNA2f$|+Uu1A7B!VaJO>Q7sHioN~jd zt_|EAmcgqzMCKu}U!5~cA}3|%UZfN^OljmM%uFt?OBK?*CYHt^7qS2s*Jzv}MADF1 zj|ZqGj|{OO>&kHUoKd%o$!1Iq?y-8A&iU!^4L;u7XFk8roUi#j?2!y1!!!s*E%?DX zE;Q{K#{)Ga>Tp9?KPT)8n{h{oC#*BbUMN{P9E7kJ0u$Hc8G}N(oLTRU^+=kzm~Pzn zNDqr>uq2SE95_fJt(BB_jO;04#dX>s9&&KQ8Cqed_dtYU5I)^~mxuNHyf}Qs6Mf4R z2O7~NtjbK>2lv%@VS6Y%eEA6%@|^Fje#8&1D|1z*yy0-zAfsI$tq~R6%Y{asevuf@ zN7ALT*MV5F`xcc+6N3g;nur>>*0-QW2$ozYRSB`hdAF-DQ|1>?w#YD0Nd&S1S`BRW z7u0w`4G)N717G8(e*n9Wk?=RHLgDdQB1j@v_!lRCz;+J&W_(JJaEoygF~0HUsc@Bi z6h@2;V*aRkx+WlKOoTK728N=X1A*P{bBc~=tz@kXWu(>{1c=)}njJVr15WC`R)BFF zx%VrD&D9lhb>1W2vnuN$@_+n~zDp3;|C_?j0~joDDx9NgZKO>bJrt&d2`h;;PeCO;Q;pxn7e~riooSeLbwBqXOwxsIv>Mv}a ztiEF_GstZNuqq6jHg=JVx6fGbM)v+bufEGG= zUHmQ&9{fjq)wVfb2H}44qnFIO=H_Z*-u;mMiwmB|8!q45bANka`h3}+I0#o)3lm~2 zcpCz{;^8;8Jb35iHCE~u-G22C9`l1w=36p7SfqN>^f{MT_I+Qz{1XIWxBl(kOaKEV zzxQ8$i+}#NpLoOT@3sYJ^>1!|$m;wt-}s%s;`#=L;ez}3|NXD^9^;X0GNs$eefQrv zVRt$4)9+iTM;O;!JUL-?`jo4y9{?u1T&*5)97q1@cJ^S+ul;*Z_?tiejGGq+{`_Bj zKpG>5Ym0RM=C9r7?O(aL^_o{_gZ+Kq-T-!Y> z)a=@M$IC3-8{on81sC&&+&qQ1icyWEgb_`su z&UjJQJkt#uM#@zA^`HF_m#63OyB3}M*8Gqd4y>nVyz}%KQr93CXn@sl#W0xsj#Mb4 z^7!IMY}0#?-sbb|`{cFoc%G?INTu>(wdOC*&anPqWfd|*yu$Ov81#abwjq%#a)lHu za-BFaoW3B)#Ci>z)q&w=BCIp_hNt|-^`G+R>xY!XZ}R7leuI~rAM-p7)Uzk7?(cc{ z@<$B28_q62V|ed<9$x>5KmLm!a#*i9=$?B~nTMG<7YfSy<~d>gz)kbz1|asGk*N7EteN-o~7@iDf2uFb$Y;WfAH5X)!Q>rIE$Bj^6ioG;~jc4 z^1;JLeDLsnWS4jxK4uqB_;~x6XT!|KM z-=mgDs_-J*a4mrk&rdmjxuPD5OXm(IpAz9_H6vk7Zo^bn*^Ix<`ri8-UjDa)aKq~K zIa7L@JPzD@evOnp5Aqe6nJ1rDWMk~^Wen_x#M1|F^KJ@=+z`jg93wGonZk-InVEx0 zcMKFx0gT`#r2UW7J{t#HE|l*&wG4yD=*~{SLFfQ`2S^ph!p%9V8G>T%<@mAYKSUf(QvA9iEUll0`7= z4J3ra-a9}7abi0zU+c2gs&)S^bIvh(Z|9-4*2nx-t*Wve$936jL{5F{`{o>%KKkgR z{oDWF{w>iXt25h7`ve<`H1yGqEI7~wNrg%GIXc;A zkFaQuTBGbnKGIzE)~7E+{SYD@C9TLdbeiU>-*f4d8<8ERpAfhA+tG;8u zTbLmO6O{!yDP8J}aS{VgIay-j=AFcieg*rm%+59|OzR^SlBnH+kbR24qU(UGoNoRL zMeZ||Ev06<;|(mV=TF{Cbk;7BJ_}hglTK%PIaN1~Ftn!E8MN{v^~>C6%kA0&nPtlC?|lf-udvW#_Vb1dhst{IWsY9G$!T5DpZl*| zxq2VrWp3O!8;rJNEk11LmeWq160YCuV6hLJkh*~n|Hu`-@E=|^S^e3QU zX|F?)(B%WlbV5oCu3r5k?C-z$$n!a~%Ovby7PrlF-1+?>TlpYh^38c4GS89k zl5xt;NZ-5npXdD&61{J)KUMT{LgWp=>C#jCyz(WZnO27bS3dF#ryB!J0h|!w!ucO- z-+dJ01aSW99zXOyJi}N1%MBjfT2sc#uN1x#E(oO^5NAw1JFKmy2(>u5=4t?T| z)@3{zlv-^~bt3{H71&QTm!e4me({ z+?_5lk)c=}({hXgzl0*I(CYGtkT+$8G-Y&5ls+@A2bP;e9W#q5v)m}p zo&2A4*Pmj&QubDNcyO>}%9mlWXF*I+bW-}eTUMj8>CFrwBXnX00m%z~YF(4cmTuhg z%*`Xd+$$HSCD(XBmnU-CTK$0+=^vbKc=6;_Zth>=bQq{Pv(07{F;QC}Kjt-4J>}x9 z2OQKTSMS{CBu!L$iYimuKvpJ!)G3=`L{Ae^l~oz}=&N_Qy)+y~XAVf*BaKH~ez4+&gTFJGt z9c&TY+nz$*LONvAEl9OPq|nO)I?0?SZ-$$V)hSu%>qyaoRVnP1!ufK_gR*AWF4&66 z?W`ouvc#Kyq)4HpW47IEB)!C#I-6f8i$J~QC8E2DJfDWIyE*;R9Fuy_QoxjPe(Rgq0h=`mqC!=Rk!0&BPPqZJtOsxVS!HapOL}wEshZ z^(-31+`TH5VY{Xb$FNyozG)+=Y}iOtJYmFL-x z9eXE7eE9S$9890&L`IwY)uerwAKc}ei);M$lh5#jeodN`Lp`J;v#ulCddwvEpl(Sz zQPY+wPi(SsSWn1{jk{HwlVGhqWqW{NPKvc=$_ShF1=P(iRx)vQy36zTZu9!VZThLF zZnx~64qTh=aC~&a>3!kFTVJJIe33GFt&KvJiAjpNpH-;iK;0ffIp#o5*-v-a=AlXd zdI2Oeb%G8ZtIfca3X`r`lelx?lvOW`lW<=S(QHz@tRUJM(@_S-X`qhq>fs6dTV>ex zocqeFNLiD|HN)}&BAI@UP(;tBTpOXNEvC%5i#+IKAU90#s{T*@6z78j{9k@^w(%J~!FN5_s|e(F5kePI}d zr%vzl(L1kjYtggGu)n|LN#U+#Ke<2(A{GPzsPX-Ae!m-o=_ z0y*7e|J-#pM=R>NXV?zM^y3B{w%koU_m(GIlpEv|Go;Wu(WQ=6pSji*F4QfH1!oy2 z;FBM^NVhp+aZ)+#Gs}ZR{%=3>iI+NE%rF=?vUz=JY3`6 zamUmB)2vo+G+`KqE8Hnh0k58^aiY#nfwF%Qwl^X599&%T;UBre@!c)^7tYG##OsQ* zD)nSy{pGs=^iNwHbMfNuE8mR4ZlY^VMsa z;kyS;=g)uI_Oa7fY;XUCZ%d*VTi;*c!i66v=hYk7qSax~GatQ3Ey~j$yFjh`+`4^) zRyX_7iS_zb?%w@B8v7-0G1kMXQB9TK3)^Gh^bT$- z?>8Xhh?W8+F-|}qR?G@2To?Xm5`AuGa;*cNR+w$z{ z6<#kLi{T1cMl>fj%Y|8-y3pMg`r=G|LfN-$q|@9c$uK$4;e!L@G%+D;$sFH2V9HOS zi>J7>zv1}l8@zDzpZIjS&#k-rATPGX!AulD-DRqZ10z*Z-4dOQltL?HRz)^T^mt&c z9pmduhV1}%7CdqMG|RN6Q{lN=w>aG1XUng0GhO0N{s7wTv0e0(s*LMGD%z}oQ-zfb ztc!AIbAgN1#v*MuP)Cv~&)-sx#`|oqT<3#z&2re%aY{**RJRr!Rb_8|%+38vl$_Zt z2g-Uw&bQd)i^hUbP}%ZebAx5s@UfE&>ov#2ZBq9H8!9*ZyR1t=lG1m_Jb8MP$sPMX z{NN7j_1Agn_6Z-oTR2~Op1J{-9^B^Ekhrt33~eE!MflKbudu&e(LeDu(#ahTZ+?Pn zi|cGx7buJjW#ni$qSQn!2i(?+oY%zi=Ex_GUg1JM$GL;A^V^5da$$YKPzz7r|1BQK zs~j93aJW9# zk5I=6E4j{H{Q$?ZAc-}56}8~w+0*OXo}S@w+VI@wgiky;;$M&V8Ok-nbxyzx9lRE$ zin8f%quUb_!Zt7LGg8sMXE?mdHr)ap15S}uxqki<_dj`&=Wlal4T^LW&3;~C-41)>DT`^O ztCc)$dH#6K?Q=`^vv6+OdNRYV?d}slK)<>~E+;&D^8r78^aVaD|A9Np5AssF)DjFO zCHgQcpmO#27K_c-`Fi&OHe-*7axmTFV%>00p9GmWUMMSnlNT~YGCB3^Z6EN-`@hCl z_!yhh^E~(J*Lb?Vg6NMJqfpH%I@ij_?tPt?FJI)O?|G@u{KzdK^&J<|MRQ`?-ek2J zSxX_6W2zL!<$dl94>+ewu8Goj6JzSoF~ig|9bMsG{SX)WkqKeku2>vRJpI~)?%(I2 zZa6r;&4qG--~ZaTxWD?(9Muiqy89GYUVobBZ+($(j+I;MB?l`dJ)5Zylx^-B<5E&( zRW_t)LN^CU|9fHci{y3U#r~A*PYkSAJ$-?53pif&Yz|g@{Kaz&x1Qtm#jAX4xXXi^ z3oaZkxZkh1rMGy%9;?v|84k3NNF-oM=3=_a(Rj+yq};nQv447j6PBE;Zqad<=lWNm zUvd6pzmI!2{xhsA|Mw4HV{`mP_72Z;xf3*BpdVIDdCj6LY}D$z1}UVc7QBA-BEtth z#qWFSIX-p#6#wbpf0@^pOJ2w?viH)zMK;i-V_rL-c;Yps%RR4ND*VvhEzc|5dIGM# z4%hCE43qMiS6=4s!6hC%3qSGkkMaNhpV4Ex(tV2Og}BIJovDZhkQtaMD5+ zYf}Bha^fkO*a<lh?<6;*;0-#0M_&tN-o4@u6#LKJ%0R3+IM&{GZ>ldXsT`Z1rW` z!VO$(COrS-MgH)Q{eJ%Um%hUC)t9-%B`$aONT->+xXQWbKf`NxzRdXx2Rzwz?CteD z@ZhpE_dGKx3E&h>2+BjiN$Y5Sj*=f4DEGa|*{527#MQ-fY=;Y+tWLOEAMiiO*N7$} zKlJoZvA+8%8`-e9{7Ihs*j0Y@)%#EeDO2Uf7rxg1y*%jO^m@Nv+u`94aCrCwZ}@%UI&hY8+Et?E?+!PyT0P5Z z^=3Eb+utr-`U8*ry@>G4$1b*i=X{YTul+yHeCFuri@g5&ziIVkkCN)0*=G`-e(}Pa zf8Y^KmEQ~7V{?diaNFD4x4H@i)+f{=6is3B?SW#{Q=2>1P)`W!-hvn7YeyRQ0b#iu z5lt+&$0%@banNKXs@7v@V6vb{6IE9foyd{VGe-ne5?MO>+GAGEi8Xs{Wgn^%jbqiB zqL3m~?{gA;ag^llZoL;`D^kPo!gSU}1SA@hnmx3cGg!ZqBxVpW$kd9jL0Hv{XkkhP z&DP7MbV}|Ec~QA_VbAvEfbGGw$Af8~Et#a&Gs=28E?D&ExOh6T_uwAcn@N(*9Kvq^ zAf(CbSg^pXXJn8KNhkkAMce{7n!iTR8UWGEpo{i0@3cdt2QfxuQ6^Fi^8uscE8Z)m z{RV58TGj2MM<%lc^g0W(YMyjMH*MU$IvnUU&XVZmRn_iMfD=)x4LLYHrmGX%y`I`- zH%oBGL>%b46B&TIsY0%))pDqGq-usAQp^!j#K2FOcdul_xpKnQa*JH8n7ZKd%_@Hs<9v26m>jv15L;jFG3ZR&wTCIxN!1-bwBWpD^FsM6p&;jMm@9Z zW|v)(vmw`tsu@>+_x2Hil+HL+hK>Hz08|*4D1EIg#oYZw*PLSYWr)&Gg}#hXCUP;h zXVKaCn$w-L!KC&aM30$OGS|EZ0BNF6Tb_^`Xg+0|P8iDQ@*-n_i*}63*tkiJ6&|#b zlO=0}QX&XI(HwdQhlv5W;`V&rwMXtcRl-qF!Te_GC=^`wQlfdU@JYE-TEFuFe~mVg{sQQ z-W?K^C(4qSKlnjzKK(S-sMh)eAwt#IwJ{;o zQcx|{|7+(}EAYEor=``Lidu8sk|1@guHHiynM5XOHE@*7C3e(}B@e|I zr>VyJiq~v;=RK_sSD_ChhwX{2m;K-~&DSTd4b!xs&-?bCNhry&(r|VN6Z(rR-AbU(uJejH05~~0? zx5Ot1ov&@-CMFdKfYVW>D{m$9DIzYpZ;GMhAY5XOY`q$d#^H1kAc%WxbfSB>RsIXcmhLT9qQ->9Z z(2o@fJ$o`4qk%k!EDjiJ655H=-ns2=l_brHE{qp!6LU=Ss~EIn>^cL93d?cyOzuqW zoAj}T@)n3Xz>cQ7qZrr|G28O!25-lmgT`>ys^B5P4c0Se--kv?&>+QlpDb9V}?VY{Nn1fN9m zeR`4Chdo~J2d;M)c`&RPm-|eMYdko&$Aj}ie_@~XQ-_S_2VOsSo^L#R#jmnj(29W= zfZp92i)ecu(8|!kVljeLqU%WS>sm*0Cq?n`vU|R8H_?rB&8IwxxweTyO@$(bsk0UY zSGNns+;RKbHST@l9O*-eltFUg#ZUe?!zxqjDd@yuK4hhLn7V=G{tJ+L5T%rkN;F2T zmXc93^q7d}$;VSP&;^2!b=&HaGDGr-$vkhQ(nHR5^*iwSArwb?4{zdeA)#mw5W=pXSLY{}>l8{P^!| zUmrft-Ah|!`Q8%0z1Q#IdwT2po~d6@RbXumK%Xd9FJqf$8Z~T=p=To3LJ@UiXM3^h z)GIe&A51`7-v^muCen8PT#b2=5u3c4~ zT@ho1bOwiDHp!dZA!3bp`)NW-ZRcg*F-zaL*W$mgRS1usiQ47}Xk(K^p|;}{x1sis zCm1JWZfuJ+1HN{BG*HxKY9B$U5dOdFjgoUwBz0_u)eM}fkg6HJmoUnfiZEIrn$EuD zYqGHy@mdEGlLx-3Mu#yQ?PaM98n)+gO;fXrp2PypDfK*%!dg3uH|fh2kdEw)erq1R+5J~bqEs;;9Q#qMHez68>2)DK3eDoZ zBxS8j?&&#hOjo&gKe4{ILLb1iQASx&`}1s;9h*HNpIfJtZLxXR@H2sRT}pLv1Y4X7&9^g8GBiX}&Ebj@P%v^7LVm_{=U2;2W;zT7~; zR9DeSPDuNcgZcobTe2h|A$>=pa?H2LD8u#{ie5mHuL)Y&j$2-N^%bV=2FV?JdrMNz zzDD{gnsc*}CtOsE&7m-Hs6fpJY`a5J_T-7$im-PGq(fwQ!oH)n0ww9JwSsO8%p{ZQ zMU9iKUGqIjTHgSiCTE;#zrdQ;dE%%V<5Yab>++J6_xw4Exo!;CrAwDsEEa9wO{(Y5 zpGlOe!#w3-Q!uHc86?T0Yn(1!xbPs=ZMf{ zU;p2Vaq{`xJp?{9tju$Q%P&Cx#+sprw_phJ`GMiNb8q|k@8!13I(Sr zMAFE$gVxMmafT-s4>AoJCbVUPFX}mpw%4K;_Xc?Mtf?5-6K{5FM2&)5!{gapPd58^ z0ysrzk251mNwk-H3uNsd4n`xZEo}M$uqKGPR+D6jwtXt|?jtPMnyp6EdpM0UHRzVG z@6UYB%s6F_;Y*r(cd2G~fU+RIn}jEBSV8*9-l|C#r<@#QZ<|yzQBld%+%aX$1cc&@ zkbw56TahC&k9mx-1RyhDlso{Ovb6b7n@rK}Ui8?q%_KaX7qHfBnef_KS@@(K>a1Z> zrAlwTR}|`y?cB=5us*esRfBEO%ri!>lQr1`uQ8bkL>7AvHOb7@2^0;fo-t1IeN+~; zHp<7674v;sjb^1TBCOKVfrsBgEj!5#Au}_)CTCUpg-xOI2y>moQ5o`%+ly*6w+m z)HC=m@$Xs~kFF!9#!wo$Ye|eQ?YDEYhT9gXPq`=6Z1+vn-R?le#yFR#KT}G}&R1Ux z?Z_v|&U3HWI+{Ic(&WQp^L$L)14<_${aR3N3LB{z~XPTd@EX(XE= zJKQ^bVDE6k4J(E+iy2R{Ky(}ixn{;eXMhZr&!A6{Cx*6yDZbA`Z&E?wppq-&xv54 z9yJ#pZ|}YBF>rbZw{_{cE&FUWA=?w4E|yQ5T)Y!O=A@P_1nAP#n(l!Gcb0uDj8mpo zp_j^XIzm(#bH}J`mM?DlL04hAWSvJ1(^DbCi`0|CWAxWK~GLSAP14kvd*lVy4eCU z&zrGjlv4|rY`hF4>`EgQb@oOmV&({qup?1DI5NP{Hz{OIg7zjQ9ga?z4J14;$n zpe*ZgJLZ_OH%b-<$PtYYPXLq54Qj!X34PhN>o)dihE+p}X2(K@fzWo(-JApr^yap7 zs{!#Y(WlY)pjiucQki_SNDC9JdQ{@7u3?5WwsR6wKV`yBjX7bb|EYpTwEgN1% z(7NTg+_#yfc9$yF6G&9(%S1PAk&3a6?Z!JSRqtDu9H7;T)`Ip>udEpl2G$1)mdlGQ z@+Ak{>QbgeNHri{GDkyI;a0Y5T9zeQjn%2lO_F2a zmL5cp43_5+d=<7DyCM@^?pdx67^<;pCayEv?d%MVNo_O3aKZMsy}@C+52`#6v*1<- zb7iu6C-CG3wsvVP4xEB<0`^B|ZY`0`+N7;@3x3HxSk|{leN7_ zc4bVuwd9saW1NETvUP8k>c-lbJy|eq*Y;fY3sk38z+Ri&POTxK{jeQ?Jq3;9$EkAORgFpE6_f4X=yX`VH?`Fm+VD~Ny89zS`xZfY!OPZQJ9)U1F}ryTCp0E+CWEGd>^0o26R$oZ)3sW{b6Of>xyM7 z1)>K>B_XL;rr*0cst1*sd4lwGSX;=%2#s;7BB;)FN9w?$Nddzk+GF2Tt-#+C(?ku0 z1aQ(EiD+l4<^a1$p>yXlJC<n{6vB|Bf=_u*{| z=Z_9nAke!^rX-VK<+5$yQ82xK07*%sNxy36j6-iyymabrb4nI?YU=3ycvS+_t4sW> z9>!eb!(iO+lAdL0LIly*Eg(#(GvJgW$WkgMlgic1DzY<9B_)%-0C_XE06B#mk+?@T zmIFtPX`7N|+>=(zxbJ+Sc+fLR=eFCm-S9;n8{?C7G}bca!sMnH3c0A;=DV?n>RgO3 z$)$P*)00$?OrItLIx^Rq7;uWQ3Kq}qbdrJU2t9edq?tolkRA6pE=@6ZGs%Wdtx0B0 z!tr>McxX)?XUUQ|RbZ@D^;$K56xun3vB8w)ghU<=n6B-?-YH3(0nu)@eNGdbaq@G= z?}caMDHKl%D3w~mOk*}$@d_~;2TXo-%*aVPMKp0Z&4IWE3+}~Yi)u-yDjkwT{%jz~ z_FBj}vww04q`JdsXY3J5Zo#_AcKZIn)|omor27bob+^aqbZQ`2Fc~&;62T!9wNAF4 zX(S-T*7t0405wTyFUIw!lt`TcyfNRWNXSg7nAGHX zwIA#{8f!F5^+F6BcFKxA5;(=r!8lEI0!i))Dov{Q2B}=NK29R(O<9IZmoAaJj;R!; z7$;BG)NTcm%phWiagtqg2$3De>CJ)DF5~1Eb@l__AqaV=q-O6m#_6o9o}T&J$@Lx# zdzJ-nrVR#O(8QXGNHM9NWd&);tRgN((K%waUy>9 zdWz}+Qq;5r;{<1FoYchc1m94lI^!gc1u}~g43D_|t9`eU5h+~JOKj2>YX%?ZXj@2$ zB8*E_Kr8FPGQ#V;1kV(kJW9RSR&WFkG^4QCqEe#2O}i-)|4&+Q9zkVB7;{2etx_SC z+UmLlpq7?3HB7Bglh;of<5b0^mmx5c+2-1$logdJDvlUa80mW8S_?6(5p#{b9W&Pv z0W(uj=*!epn&D^_7Th9cVj$WZYo^(3;br4B6dvgBYyqfLn5BARl2O%;sGk#PW+fWt z9L^5)!8oOU2WI(@IpdVAz^Va3a}pFZTSbUgyS}cOLs+mKb9BKS&=XWfYx;`PG1>X= zybuGzPY!D9&fl_bS%fUdCAVP)lfq;I=yeY4?dsK^dnh90_EZFGo9M-C0#qERsnW?T z!;Kl0omtFzVE{)!#Io2XtIO_z5>Ku_uQ_3jtP2ZW+npDx0XlE3qO2}-R5 z?bjGVB-?WboGdbRae%BYkoPXJuPge#kg>p3wDVd%rOK94Cc7Sgiy0#lQauA{g^^m5 zxiG4kMeGaCUYLoBP~9X4Zg#IDDx4eV>MWnYmJ|`#i$nq)K@BI8%f5tX#}&_~kFyw8 zkf38g(h7&3bhuQ{pB+ibnp@WR?Rlm=a55gFUVBzb2Ri|M?+K+^MyhJ7L=zF7KldSq zYzc>JHS?jVXWwnUlL*rFpu(^n+2mU&La7%J%pk;oK!6N!z)@RWolTTX7{1qJjFYq) zCvhM&Gfp|1VFA9ZgEoKi|$zHBBD zvEB!8(tZyR15R}^*&Z~;$(E2r*S)<|Z)Tigjeh8S-Xp>M&h&p*Gfu4s@@{&s0jGE3 zj2>^_>+LacdIz`F!m@Cud4;Mnp1#cb!Pl&?nF!E@iP;+{rwLJIS=Q!^CW1<4O#ZT} zwg@Y5us#Na`@`Oxp~LGPeBWC!;FQ!ewy-0u)Aq8QhS$;6D+nXU3|@?1EuhyPbDtB! zhPq`VrE3ebV0Prmv-TB`>NQRhfmQ%44>(2JOGQ(quih=iG=lX0GPD5Hea<}iUTNY$ z_BqXKibMeI_6?B{SIg)w??3B28aGQ1R z(%vp0{><>IDE%gyLCcb8I(r2sG+oggbkMZylD_S1`F% zM%<*%gKD9G-m|ezxyc4gxQ+RU*ImZRkZ-#esjgXgb~x+Q<`B$MGYq=;UGa&dCT9X; zd9pK3k>F4=olKDGnd?t7HHlvUW3c&@q<1#d=bI?KScRY+b(Z{9ftrPsEP%{d?Nmw1 zQMn5{`we-nv}YtdG`+4)XyzhlCS2>L1k=HJbg=>zR@$)~Yz1lJ$ z6cLx1!KKpkjC_!sGKos33slV7JWXo>8b`8#eYiBO6Ce@pmY3Yupk`SR!Z!gs=4!Yiqagz5)6u8SWy%!j#-CI%~ z`rG5}y}i9h9+~&&cCcImu+DpEh3WKV#?#jwFr=30oitunkc{%+U|geaU0$^_n^a$Y zliStpua8iyfIAxC0uTk!nmCn_#AMmL;_?oF2xx9g0*k*|Y8DkT=vY5r*Qx2!{xVb%6r+ zd;2^!mmHvdoe8h1+<)psOTJKR)1nvgrx{w-r0AsehwE^3x@lu)D zn6L?s?-)R^Eh8qA6O+44TF5#%YozU-Wzx=AfvN>j>JDZ~p|~A)mL0GLHkZ^STq%m2 znSqmf4OG0mlg2*m*S&+w=!evM-z2*>3#P)&FtKqE+#|JOL9{?VnZbM1{4fhOE#S2| zs@Smv&>GTA^?HUlZcM3=>Y41Vrml^DY}FG2SwZN@-V-H^L|)$?xp80&uAOo5=fJKl zYxU30?vrD(-ZQh&XbPpa1dWtZ2g zB!32M3`LaFZbcGUvLRgTP$f%g3~$W(s9Q{Ffva;HAWu?2W3G81tb&R?0ipb?SiRR# z{{Vdm;DupH>*M6>fz`9`7=!rSj9FM)&7_@ArXc-ja#&TW3S%=b*do;C;AVA|!J_Wg zP{KIbbu3CxNfTOwrBG5*bJg=l?S9^vE1p)buT#VaNt|L^)scOjxLDVSR0pIpYg`zO zz!e*}+>B`~W^MP*gQ%1!I2eFWq5kU7N3c!HAXk|jl~jmJYZPIWSuM52$=n+MAmE?yw{S_cnH^#tk&b)27< zY_57C)f@V`pIdno@U+{<=?#Mh?S8)7w_TR$-3<2T8mIYwgi*v};Pn33-o?}J{l6`j zX8*a)OUvrk4XUHb-$Yt)Y7!@}IS_O6I@p}RnVu`2A*|AZ?)}X%O66#nSf{}psI(Z1 zFl@k@sRE~I9<4;G^2Wg8`@7&TXm_xkQ&F z+f?h0w8>Am_;z?8?^d)-k}g0yjqdnK&WRkQ_DJ&nL{W@rrQZBivvV^#%3l+8&r1rpa-SVpm)ldB$Yu5Q%C`$_}s^} zcuk7#0H<6>e(#MF{>V3Pv6{U3Wn|G?Q&bO(#pX@*y1zbH0FhR^rk*5N_bUWACr9%{ zLFqzdiAu{P~Qv+n%{WX7|!G44|+$ zSzFC#zKKX8=fomA6BPA8l8k*)tJShyx->3sdom*nX|8%|HB8D}<0Q#g?rQRE$p&(3 zElBQtJl&K?1_QjzQoXPv7occu<`BCk#+?9VWJI8M;6!OPPED%kO74 zoy;Ay&pj$UTB=vAt9FqLZ&Bj}ko%6kJ!4pH*g~qeva2nl*E#unI2rhir?%e#6XTo6 z^&YNqdV|dEUCiF>ZfAkhyZ4;u8mIYp@$+M;-uq*F44mGuj%V=H5d1{ZRuL*_GFdK$;7!dx}SiCeQ4W6^3g~3?76Pm)B_OycP+@ z!EBcU$Yd>OGIuhm7WJAe@N@=^J9TSe;&4>=sFJMy0qcQeOi3$O2RCGs%+7dQU>3}y znL|KW#Uqx*R@D2>|fsmW=ob|K{jyA?dllZlWKZ6-T8Ma59lhc+#7PUk`7cS;8 z7ntQ#$z_aaMWhzZPni2uXm&U_kO@gDOnjb^9C8 z`667~Gm@z~(xi~{K+K7~kg672m#rOwuPq_fOLGsZOhvMrLrleLoIH6^$Zr5nNy3hN zp2hL6H!x0RYl(}+ew)`xLXKCQximu%VV3HN2-{+YCy!#Bc7c;3^!~kBs&|%gLX{%f z?#EjM%Ob+w-u`?%@5`jk9AY~ICrOYKS|{)0l;}E_lJn-hoZik=kGD9#chmM>F^35G z@U9(s0PFl-8SKZ~TW*hm(>u5=hTdy=G9@oPZVi3D%&}GkiDB6)6Nj5q%VY+~Y7!O; z@FJ@_OluTacLTu$nT6oL)wg zyMF0JSBl4$1^^#u;=UNORIuQ%Y&@fDl{O%iZf}cZDEkw|WkPlrGNFslA=OKBaA0=L z>gQuYaOci+N~Wtju6mesNSqN|50-f?j*SzQnooUSR*6wWQP~hkHARh+?#^usoU$K( zlH?4+Y{4wfR^{X}PG~m1i)uyzRjiMbX5jFSYA-C>-9QHulxKyo{1lK~rplf)UP9dn54fvr||6DyN9j-4f+vwYJ7X{CWU zTxw^`u(tcd&fKdK0LDORW-_p5o;92>K^3YLuazq8S`DN*u%{AMf=Pw3nw|c#4s21z zG&-m<;Di_(t11)*ii{vzzczyR_R|g=cc3wqzphniI>eSX!hMts#mG`-`8m9%KusB|$ zB24*y+>FM?md0*oW1qCn>zUuvCP_*?m5S7vaT0O4=T422&0|k=MU9g)PR0$XHG6iT zv&%S5I<;3~#o1YyoA6?W8B7~S5)21E?IxlvMAeFFp{UqODzhEAAdGbeYO%Ejxc+RP zj3=-o)$9BToYX+JeR#s^AkEO@EqnJQSgn?H(lyYLhZ=P6A8xIi0Wl_c?ST+sp4La-4t=__!B-hHRD)ejbYhxKLA&T{D z>-hto+g4a{iYT1YTX0DLHP53)X3&pY)EOs@z|_x;2qb4_CbiR+1{`96EY8~G##UHB zvn-fH5*AF4bf%%#ib&6C-gwa2wW59N^GWeXOA zwMdncTBVBv7CXxZJaJ7QCSeSVYzyO)*F*p{kxKwwudmpVcCLrsUgkSJk7`~6kc*97 z%@ehonV4CsXVOBzdoxJ`J!8t`3M%~>sh+6PcXeiz++e{NC$(V3_Z`e;C0z9Y=~}H& zMVOMwe(b7!-n6PUuW_)p9ZvAa8O%F(Q;!sX~T#_3=RJv;1kqx7?=gY?3Gwxc=l01d& zbug5{KKXUogK53J95~I5l;gRX=R)gW77Xk|u6jy}SxrUB(jk()p2gA;n$>QATAg5( zV44i*A-hI4N|gegf2Il(8^EM`h%h-zDJdI!-K2WPIGLfyF=6yVaUkeGX{d_Q+kA0= zZS^uPKV!6-BgE&rnuHi*!CP&RuSdZ+l`=KP;oRPN6iYyK)4P9u#_ZdcOR>9a*!Xgwvg(z@eOu)22M2@)27wy z5LF?$9r<>a>dodWN=n&*xFW5_$$*ojhopMxtR1<%5B;67lhw~@mvIWs8Xx- zI*UF|gp5}bW0`^4yw9^WPP>egrD6PC%8o%qFi!qFza?-IV+pT4`6M6z*vDq6Ubp0o zIYhjlMbI+Em(8TZcR#*~C3#5r!d34~)b}2W0C&OCyP0tcR_RQQlmGW|1Kjt=_8xj{ z-hW%?UAz@RJ;S8FkkSYz@ht2Nq{!CEUFziZLD?AqT&iaQsRF55kCMrqkL=~+ubm2M zST_b}*BdN}F-{WNYb@vZ2eC$awPfj>&$~iCtTbhO1^^5i-PPz~b}EdJ5SX zBqX>!o+vmxe_2cx3e>MeuSj=G}&Q>jUrjE!1#D-LAO zn+~@~+izz`i9HdqW4Rv}Dj zNY*CZ<%`XZ$gb;AjMJGKr)0oM!c4>EyK!Hu$-^f)dtba&ti1C#BQO0u(Jg6xoa*E+ zb2o3Qp}n=fTw%vQg=P6e+Z*~g?FR4fp+NqJ#kSqgZpuxwi^*HPH{%Di;;vwPz+$ z)$NayOZBbZX2BX!W$Se#mf1I9jh&@0-ioWiUiwD>B@gt?;Suom}zR7r&?bpArCi;6%}H0-RcZ<2-C z)$NxJa9WMcT-OrJplU#dU=vIp_}aNwdC+}}I=yUi9W7p2=9cXWldhZTK!<^VtuC9f zLFYAFHCcdnR;nlNpHb#|5_dkcAS8K%RUb=%>V1gOL|7TlOj*nz0}qu>m2<_$e34FV{?*PC9+eN>y~pAD z*cqU+iHU?ctR=j@Nd%n1H1?Yo)HX?>*Lq2E_ra)r+nHPOJkKkfdR^cykg)sPwOGOc zT9#}M5GZ~fDRnz9U4Ldms<*>9eQ@sy zR{e@hCg~!&8xi$xt&dZkOycJ3C0JcdI2syoQU~4M9CxrjP6_dv&P+}BDfvF66HHb) z*Xvas{pobDmd+Y8XzDEqqF!r8JlDSdO_Ko-ukq}Hb;MltBxNI4aH(E0;1tZ@ZjF;* zwIlJ2onf3rKnoKII!{FI^l>t&-ej_B@8e|l=jn`G?af^EN-b>4hUTh=JzuecwLsY! zKV!e;ErVqdnL&W+j#O`9S6e428wcTHOkOZfa+Yy=vnIF?*Eq=zl6yA;kcYQ3jMKZ= zW#LhFPRL&N=edyDNI2Tni#^FPn?&p*#{x#ZKI{xrYzOTYA%pWkdY{I$RK*ZANE zKgeRS;Dr}n;1_=37rswt`@P+|6b1!Cl?BVo_t|^yPSa%15*GVcNcpszSYNzIiUM{w zM2OFr#3=$nlkgRPsSE1zC?(5;(6=W%GQU;qg>O<63FL-3e^vH%Yk@}C9BXQFsOYQH zT=lf`^NK9Do&iwex_xA>y~yH5-icPfFj5gsUL&=os@FIXMif?9KGKoBFO}d@y();B z!;t|jWfCE&dQFYVwL~p67)3c=_l&hOuqCs(1(KUxc(|q&iUUZY%7)Ud*)C7Hv)FQL zdBT*oM8Ipz;hZ}bteE|zzlqj6s1^kAdIqQ(wODgGd@2@12jf%)dQAqH5@^y{R^`Vi zVvSr|U4osh|7&KS!t%Rju`vdQ$*(tA(6$(7sfePCUD{!j3Yt#|7C=yHvYM+_-YtrB zBP!}ln}vkp^P`FyBdD01DXv2uoTk~0Pdva|s0G7Qv!wUTEnXJ}E;UM&lz1Quw%Ri$ zMf(j?%2ZKuaaKmcv_!nd$?jdSN@GqWDg(tNph~kj*ETOa&}@v8B6T9CiPdnko#uiK ziQ+YX!8m#SotRWl131N{IZ#H_8~RpKO?2W;eLKMEV4660eBY#do+F91B?|HF=jvu1 zIi7ZZ@MAvNH5hOzO>$Xx`ra6O7vt?uzCeRjyXFv{(8%KJfS5csd5x1fg?ep~n1oPB z)Mf$hNA$HLY1E1-DQyk(*2KsLP?mLpr~@Z#pF%eW@tE9hBi4{St?qMsxKHxuOvLU> zub@~hU2>^jMx1dHDkECF&MwW4eR%ztw1~<9NR#T7S*kTX;9zlxl%BK$E(45o@$_k- z)Jk>WC*U$WXNvgi37e_s`q~(#_3&r-gAx99OuL%|JWSj{jqg#|B>Il?VtU#f5u<@i+_=y z|M{QiCx7xM`3L{tAMjH@^;3M|3t!;5=bn4ycYgY(f12ypuk(-o(LdtF7hmMYjT=nU z^vKV?+qW)DDAACV*njc?Q@KYH*-&K(#RK`!=!?Dnlg^gRVIf|Ua#&Bf-kopGQD%@}0dBK`j-ZJS-4Oxm8L6HJ zJ4rmK(|{H&KokdgTYqt9l%%IrIoB8{FP}HYNjkEQ4yF>DJkqOyuEu;xZ9%P|gzd99 zs5vc}?UdOR3r{RCtPU=8`Dk(yxk4$HC3kU zz^erCv=6AL_d~L*bucNZDpjpdm7?^Tkp$J81x@j5kgh?<=B^81(k!jUW)(=oXlnNqf3w3?i;ik>+y z1F@WO)l*S=t&MRyYYt&xRoFG7HZWi=hYlo?(lHru@&PsAB&~iX3c*s$!B*E}`|Q-} z#*$`w*%-Lc08Vy4Z4LzkCe%8Tfy}~zj5-K#_E_fLLw@E|#DnBCKdYh?5BzIl$12^S zh|=bvsya)fG%V>2LhZ?p&QXb8oLLg%|3tFY7zT*J0~BWtEun&+M|H**WXg<#xjYWF zCu_Fn(>XLaK)LD9u`$l4vb6Ir8;}*LSjCw&eJ!3e>DxWgoJbTzI$%qYi85JgBIaSc zw=&P!#>nKII?4!w$NP4lYlnz1f5N4Dp7=ovQ#A>i?JTt#8-S@Z1~!;xb6SMDSkP_l z{V+*KNtuqx+%*B+O}I5X@;Mn{*N)Hg1Sz3aNO``#*=?^_16<3pHI}eq^28onTZ}sk z!v>S;1sk;Ms%Ps)I&%&XK+b@ZWOqZ=LQV@`=K^TrQaz~p){N7xImF3itnR8iK)CPw zv|8X1nBp<7lbwg#k-x1xD-sfQW}NI*V=5H3$Nu85H9ib+f`JJ<@wTpdkLu&}j;GGQ z{cV>idsj0~K2y)ykvn*O_n!9S?K{}sQQ-7<{?6aw&;Hpz%b)vme-41Z`*;5?zxa#4 z$lw3_f1jWGxu1K(=l|uu{FnT@fA{Zr>7|#rbm7~IZ5Q=`ZCF{x z%>x;B7tsiAfs~vn5^Ft~)m-&daQj>#D1=n!%wcTFNgk&7~g22fo(tmv)*hgjExn$!dQ5ty8Ei zSQfGRq;Be2l>zc8W4H19_z0;Upl;@1^<-Xq5{2%FGcRHEZtuEOtFw7FRGl+UlN4%p z8*2yUQD?H-o5nKW9z=(;nR<S*SzhL*RfbYVogq`2AoPR z4x9q4M!tA1G&fMMF8{OnWMDlQ0e>d^f?6LZHM!VOwt%ut{mzr($B!B(1tC*YBG*b) zVaj3*n}fn!W;tWH+;#D@2we>@XvPAaxE*k0Qp3=NhokYWxEBr79G*Zj1vfUD$IKY!(L%&{u?x%-YQfWI6?1VG`a%5uwAR zk!yN4uc*{T2Zsm9R!~l?j;53u@TWT0%Q4H#LRk<}J)l_`m$D^hO_Gi-mMdR7h8RaJ zlv6=rH73YxP^p2cgN+$bm3*quI3Rco6kJ8w05f00e32AoW)=l#^w zYn&`KV2LWE)i}-fU`7+W<`BU+t-3wnep`d0W^$J5ji@S9GQi!x9c~J_vd&D388-!R zI5$2CsxkL?`;PTTF4 zU;Wiz<*)pezjEgHpZUyZ_?2Jzl}CQ(U;K-I!H@mekMXzv_TT28{F8se{{B9H?2r91 z{^sBOo2*u=M}B9s*|6Dc+Q0ALzYoATj*R2@J-V9jZu|9b-sRS|XA4jjNiMfYUPc?w zm5(ls9H5X=0MX zxq1RxU0NVi3nx50^-Qj_D@tyzU=~2u8B`?;W<#ze?bpW6cq$rztr%;RsU+F>i_ii* zi~kd3%ZeBEIu=GWb@Zk4%y&3|RR>P9IYH4xDdH|%JHt+zYc>Etm zF$YA1qL6fI_Pyq?>@`4y9MBmjXLPEAnSKgjYR3vgjp#KscA1(25V&ko#eZUZ`5Izfoj($&ayDvD`6Zbk*2O?tiNL8W% zt~b;avqQJ$zb4hoBrd1RP+zuMvXJT}1D;Z~MJ~zf(J`v5Xl%W z*>wYSGZyTIsR&HgAX|{exS5=Br@qPMtHzF1ulETCDkAvILFw6G35W?>j5;zKCaU%} z%QZ33BWlc);Pr$)k9<1Y{&TQ==7_jODY6AJdu3_vYC77pqx%;2N|NwN|# ziH__wMAZd>Ge9Y9r@}aGn_RezYX%3{+h|UUI`}rQk`^oUzRim%Wu|KDM|QSqDuqoc zmK4&-4JYD=_WqQ~EbB)HYQ~sUD8<1|qLzvj1Cq74)Lg9(Ua877jZmv6shk<7vvH8h zR402^Pa|kWH8YmNR_z$M)b<|N?HW}}vK2K$iD}xRMX6OOrLf(uDRuNDU1dAfcu`TJ z58G53V?8O=zBg@ouzo-(g&{4>$q+ZUD1}-or{l<&K(=eN7Pcg61*zpNV~wH}t%Y$r zQrrFCGIe{#c5jZYt_zr^$*#%!@{Qw27AU2%-aI;{*^Y%;3tH?vidJeEOw|02$3frj zR$Z0~#sGdl&O46rog7PjK5VC{eQ!IB)MC%Zdu6=8AKP~`zQ0@BcXAHz7;t+1_17t- zaP8W)Grzxf?HaGW_Sz%A^U_N%@yoyb%Pf~m{`o)u=e+*<>-@~m{0z5m-+t3Nr=R<| zpX0Cp^}qgx-~X$B^{?35+xwkg$nRkL<`FK5=nxJ0(%d}KGI>!G&GP~X6!L11EL0~fWfoj(oGDl@L7f_j1_00qTnj2bVl$ByHWvS-I)kDdXvnF;P zVVfM7p{8nmkg8Z9F43$tYRJ?9S_rKmQ@{g_DmE4ds4FGcX8vGj>=2?(O$roN*>R63 z)q^^d!~_Eax>J*3zaMI4R~%cCu?4m#cSDn{-%prwagY@5a285hk@wDy3;|NKGHT|2 zxyoK-V2!SE05=#L(8WUY)c1M%jn=hYbMHBLtA`2J*W zh;9F=tm;TJD^R@umdk$q`zeC?x^6MscdRx<&!_TgjC(u z%hst($cp1yYBY?F8C3(6DM>n3&PW#ulLPOL#JE0YyIIjMdS{Y7Tkg!`xZS|8XV+EL zuTiMESbc%lENY#Y>K0hBDhsyTjR7ZxakFqhs7w`;>dFe$%B>qOv%Y`9q){cIoq_(W zN~ykPJ2R7};>n`QcG__L?hUq^Ei3VPhC)?tUVn`%H}7z%R!&dWeC~6fqw9X1+jnkL zZYI7t{#VxH#I0L5=x^OLuu+6tH(uj(c|s8osocADi_N72#>IwLUwe%&z4k=|`&Iex zzy51{x=yH8UcPgefqRVW1CHwvcfa~o4vy|{aO*Z#@8752>o}d1&K=+8mH+-59In5`>FJhZ9`N$f znsR&_rZqQT`wH^OPx5d7&A;X7`c1B#oO1p8%Y5zYU*poP8!W!{b*>)2!g4WEPq(~! zvZd&K_U}C4UVo3@{Niu&xo>=q-&p?!PcHA#OXlV4zs9Yy$E91h;a=sNpZgpDo3iFs zxy=Jr{_Vf}W%~ZhRDF$KKfcKR;x=-(aQo~3D>oLmxR_7)#)Fr6?f5@(bA6MZp7FZ9 z?|$){zt~u(m#3Hc^7v)$<$HW7eTlD(U*RYpF&wFFuguV3c}PG92L z+qc->TXVYkLAG7xEC1$SbN>E+;nuDDtWSFGe*W`h5ng)fC5GF-&9@HUxc@JF%j#AC zx1%qy>fqd+p8X?x=EkA&`s=^?rswu<+BUZ{>sywjdHLu!=?@;wu>Edqpa1;lzwOU{ zB`^4Lx8$U3Db7-UAust#x1dfNPRsgt>oni9+jla)zgyeM$;r3<*>_Z`2WM$xz;*DC zrZa0bS;jy8r~j1m=g$Ks_xt02{EzeZ{@&kvB=Et`>M6Aj{wll^QNI{Ud!9dyu%HFQ)53KF$8vE!Po zmKyQehFPxE0x9ezTZ=YTV6(*)i?li!t(jotx3yBdhsq%%H^e~NB$naU*gtdj7s+$R zTtV`zCy$1W5qY*ItQwwjfU|E~Ks0;9%8k{ZILjh#MQuTHFivJ}p>At!^#++vW>%nd ziBmE%DIyEH{0wQtmG;5q7~@o>63$yDd-8e@WXB~;49JNZ^F*f8%!c9_d#gngm9~E? ziZ63hQ>_M$-Qc5203Vs1xu`6}tf1#P61KNWbt&7ftKK9ASfWm$V3Gm_!qz>QC!azD ze9W5MhT97GQxk8?To2{7Xe~HS!8n=OL%8n&P1<6&P}=<$4~!4{2}HO)J;#&5RtA6* zkbYOEVc~s8A$bs6Q_nnsXtK<(BUce)oSfyM2GCTxQe7rDH^8;_0Er2qcU$c-&2!X% zLYUJlMY3nmA=Sdn^#JbXC0=J|J%DUZMsKQcM6;pkW?&=Uhf8cO=Kvu=-o7SRG?Hi^ z_4=K}LP1;A$n5+TQoUL>AWJ&!jbOrRoKjNy6t^+fBxh8+j;UWFvTij_C@y8Sds*H6 zE+mEE2@p{vIa8UMX*GwkXcC+%mEtu^od}CX&tkDK)^6t+8+7254SRb76ukNDEcMl{ z8jG$5AhUpWwq_obB}3m+u{I6EaETg897%{|Mj0SwE?vIN<*~3FWyw5VN zIVT4!`i{kF$@7;IPh7dgH|{Uk@Ag?9_nf4}#Y>m?>}NmAumAF|F}-@13m^X!-0XSf z&R03t@A1MD&$4*sE|==Wg~bc}`ZV#GKl&Md`Og2B)%_bh{nRy{fBt#)mOanvDVOe_ zvXR^Tx96`hoPUz#xZoL{Wy_Z5o_UVX{+`cr<2SC8?tYme4}AFAr}#*JiM#*tSJ>OX z#>YSVSpe?ezs}cw?N>;tub9+bq*6rV-e5>%>;d5MATp+!k_~ENR%(K&f zXZf`?SFS$6N3VU5^ZOs*4?S_7=T{5l8^6N+U;8EYE?nY;XI|isJavr^EC=3fJNZwq zQIAJH^?R=J+c&<>_3PJp{`u#5?k=SN`X%U=+}~V5_nzd#pZPJNU1y`f|C<-3gEd;mZ`zhL$0 zC*Jhj-c8$UFWu)`zjX(IkNo%(oWJ^LmC^Td8^@8)fBy6Q(Lee}>HGfezX1G~2PcfT zkND{Rg3n&DICXXV0qMahzxVtefAGS=@8&7Lr?&5Ae1EsLP@{c2+dBrFu3Wi7&iM`O z(v2H8-oQe|_S92P@ys*NG|&X_iBEh2RpndX`W7Gg$VcAroyB5dFW-l@zVF}h8?{^v z7f=H&qO)^YNL!|A1`JuE5oSOdw+4?L7ezV`l)PDK1djqcEk+GU;>cxf+5BWumQu5Ir>}GN-2&4@Cl!^j>!z7i?C}I$_d_hYZ@C^h3fbNH zP(tREtj`i5UxI0eaSEv({@t!5HmyI7eIaC65@V7oCEMS!Qwwt;Hc(BbF*m@4UJ7_8 zmg4bqPD&9qsU9=qBzPC|S`5^ITh9Aki9&NQpe@d*I7^|Ln?%h3SxCq1z%?b8c)1`^ zD#+;jEKI3u%$SjJ6G?Mp?Bbf@y!Nv(ipS*=>*VGI!VJW^XxbWI6FQWx7K$oGdY@1> zx8l0F7s?UK7?y z?~YGuQavo-p83`|vR&-j$F{4bNhfPIn|T}W=$SRMg5rQYCBIH)VU`^$%+({E(W6}h?zr_0JIKfO%TnVH`UQ1w-(2NXnWS?Y@a*n@ z6{)Alo$FlQf4L<`QaD_uZ0}ERLm*uTow2$Z7#6)THn}6^gp|T!SRmmtm(^_7Q^HJ1 z-082iet`Y7MY`$H*e>J-*6j;GwA}cLOA;&Y5$|bL90v${nc+LlRQ9>+So#JvSwF z%3x+70J-np@i^$)-G-qjdu%Wa-{1J{JBb&EuD5xgcJ4>cq?{PK_s)2KKeu;7JpP>= z{~ar_8-{^TfBMsJpy)pT`OotQ{=gr2p973E~vVn_& zTxT7SR`U~}z}(zCyDwIP+}G^xXc5?WKpf*CiYD9~!U9f{ZyA$hVlBTekJJ;DUZyra z6(DS#v11wQ6hXRys~ONil?f4JcJSj00kpB+OfmOrTyq#r?LLAu+Gau`diiiex6qhkG<(OAuUW& z8w;ErIECGNuG-u-p(9-N#KB|KI5oxzsG{uQji5=!I{R6xH?szs9eJ%AJPJm1AQ&f_ z9l6!7#P|lt-Q)qVK2E9z4jSVG*3(J+-ZbFuHD+lx=nd(m2_)6$dUdHD^kQqHx`n&| zr%b3Qi@LCD%hefP1DX&3Q0DZ%nsJu{xVmlkQ0}1BL)xozUh$gQb!@S!Cl0P|E0!gt1-Cj@;*5C+cPx zl~Suqpgj>)rn$Z_i-SO`x67(@U57504VX@;GY7~NuB8Q4V@mUMVs~%H$VbC1FW70Z zx%hk?)v8#BF%nx$t;< zPi*g~H_6Zb?9cKK|KUI67k=Rv_|4z^P5#nf`b&J{8{gp1|M@=;n9S}^{i#3IKL02G z!0thk*fvqn-bQ zTAbBMb#7597U*bXW>x2YFU%6a;xB-N?l4Yx!7gUh;K6TA#>RAP8#oXWDw(M{V+ko) zNOM&8+Ii}ZEGSa)Rh=PdS?u5m%#2|M65`C02lJRw22!b0PXcm^emB@>TAw34fX_@( z$X%x$IiQWFpyV{QKo#Bfsx!G_K+q6l1;DY}G6&Bgf+_@Xu)x9G2rFo!s~H@MS<_y> zz7{sQ)wR3oWwqMK?%aDAbI;tg zxtg&C269IdIeT@B0D45yjhll2T3o6Jot6eb&HXTDS7$IeY|)9oVa63vs|aXP_OMzy zbH7W3_1H3P_-OsAu|DC9R*Tj72uK~=%)#Y}5;H#%2oAOo#vDc)G&x?)<~kWQPBtF? zU5P$S1{QZpoop^hbipy>o8pXZ7m1i^a6o}miAJ^yi}zA(u6hxYiyDI%b0Ry~)?`3& zRTnK-uXTi!NM!|Xz90@KM(I#0t7<*#QVrX5#dCR18pt_QmrGwq zlx<4QK~%7sJ5}T4Xn@5V=ECg$=y$H*$u>1$-aBw=cH~p>`5Sl1?pejm7XsW^9h0J$+Jb|W2S4~h0A79dRlf0!Z?w-J931fZ&wrl3@E869KlWok#^uYG`RSkjY5vyV`djbR zCH#)IE=vo3QuNPo79pg1763XNDP9}kHpsySRrSEd_nXSpz*p2b%~HLc#Z}cLC4GQ5 zcTMuoc5G?=a@6A1>REYBkTb|OaZ(qo{JQ~+=46XCmQ_FA9Cpq@a|F~8Y-I^1NFdqO zYw0aGrBJhd**;?RDzP6$m>j63Isqxt+o;QbIvLT#+}mmgI1#1@^3Y2qm?RGh6XH@Y zv%j^zNOo_MTDn^#(N{aBc~97RB${!u-8C@~C#vrDHZue2bDB*ol#w0jnjLqPo-P$*5D{;d%$zOO;>ipl zn?*|lh<2WC3_<5Pcni`~t8ucXtAvD9Dk}-bNwB8a#zXI?6ZX}b5~n5sE>tyxh%^}s zV||=5A?Q<|w_(*iVK>VRXl&-8P;=+!Kw}WIyMEc7btgzK+|#xKKvr`V6`0LJMCj;U zX4uj;oG@~L(rItND%o?Uo(l@;Z)r&mXQHT0s%Nbm3QD2YtpO)pf*koCtewG>dNdd( zAZtg$9T(|*?XlJas^Uo&XPg4IB}**CeHK-6ie}|lZK^6F*@D^PvP+=W$y+xh|9fqq zT(RzWVd62CiBiK#UeFzPs3{3k>a4a?ZT@s!2YqkBv{q9Rh{?mm0ddiA0o^poa%}1V zC)Vp|j;y|x_I+jxgk`=I12n^JD~dN2q_g$4pjt^uX2waCMOuKuX4*LOIm<>(j_X6b zlhv0xl5xh@(;+i(+F_hrNs!aR90whc!5bN;&gFx<4RH7RJ=W34PHXFp7k!+xZ2WmK z;bZr9LHP?UD^sAQ6m(=uK*grDO~j;V=d4# zHrXC3-X|$!CUa4CX`!nF2D_-10d0XF=D;;CCuyfn1yUqp#e!7J1l9(egbhM*Nt1uJ zByx`W8w;aH89dmTOkz?!C+uuq=hoRJCuCATH2R z+P#Vp3U8>{m&nYD_Y(4&44FenO_}7tspQ#JuYv>5891d{4Md8abBS!P>yw(bb<7XX z!doqdb1^Ag0Cz#Hl4`MeMlb;iRp?8xrnh#3+W3b$Pf6*H;<&l+AMynyX%u3dJO_`;v7+SWv|STMakDof;<+HNX#6>(&)a zHYiHg!Z2CjKR2YU&27=-dIe3wxTA?qTHPw#u70F*pfj6lK*(&w=J77$Bo<^VZUBMH z#&QZ1IhUjP{F3BZ*BLl1*xK{!$pUq0R8FJ+tj*?LYNgaI$P%dw8(Z;uAtDh|?fw>b z^^~Z|GN-pVc1^iS2&>CDbDbOLMp!CoHoA!|i`8e^5~B@vB$TYZWow*)p7NGWcDa-; zu;pqFe8tz3nzS9$Lgs?%+>*kiPnD`0lWEmqu05mkYjwt{Y&-#AiH59|O7B2zuE7$Y z!v(+Y5DO%Myz+l2A(^x39>6JiFQ1tytJQi>p(de|8Z4jzI|EL3Ev1eW2k0Q^G&TUQ zUB{R^mZDHisnB(uJ;OtG#>r|W#hYSxUVnFnaYD`n@U||^z^S^tI%%bgzEnF>z45iz z=>k zLh(dJPCccRGku)iz&QE8r#kKQaaytQwHF@EI87u6IxxIl)1go+D`%y8i-&;I!+o66 zS>QB2q5*C&PEi|V-`k1a-$M+@F3a?;W}G4d*ts3?^JB*8{jt5HQoaAHZ+C9pWE|b} z*TGU_JHQ%CLd*Dq^|w)hPTay8fCN%o@Y%I`3t9u*(wM9W*lj(oV?nFEc%o#Yy47-K zoa;QWmuC$ID4Ba)*c?cEk+@XN7mC>i!Ct&2n2^|_FAUOxujJP0$zSFwij>}ZNl~HO z0bey+hF&d*H`l-fwL_}csT6zZ#@TksBubOy9hSf&9q)T$XPIM^USmcaEswTTu*~t!zMW`;-qcM!BB(A>x zgM4K3)i3Kh)Mb4c+sdhJAkf|ouyPt zN(^x~JOkfNN-E*B7iJ(fhSb!W;BHfHU_H6yQyi?Fj03lBoi{lWw8pR@)f25YOC%&l zValT9YR{--<-v2e8J>N`u2*8t*xHbHk{ZfHpC&(_WC+wXtw~B7=T`TJ)%_@-jd4;m zg*k+!3nZnO`Vs z)1j>$g4vayiZMq^T{^+yvL&DYR?p|bbR1t5m@R)ShT5o3<#7TVH)DAj-y zDKWP7v-)+}_-Y-^ULMG4uo|Zwsa`a^jV&0clj)?*=w)6aVs&FmZEIryCoNk>Ov(qe z`m{IO8j#sxoOY#pZ7O@>Db7C{Cx?RV(TtPV)|~-MyT^X(b9*;!XBemaHiP;OZcVDU zvj)Y_k87OXAKQEAv3dV(L*F$nCfcrs6wjngtv5U2S~jU=)4Nn!@X^=ABmoYf({VP3 zXf-WiNA9}(2v|3b<{=PU)HMxt)3R!DZYJL`%j*Q*0M`SxU{C@d#PR6b&l;{qc&4=h zrP1AVf9qNJbJ_CSwY;W2jaP9gRtGr?Z@_7G%nn?VjaJ zmc^Tc@nk?i3nA6Bpw~k|vC?pJW}AmmJOHv_Tv<*Y9AY&pB5{xXqSeehl2-a@?NUAa zt`)4CaH}y+VvLiz=|KS-e-Ce}I7sswVdI+ohJ*ymZ=lWqLjk1sz`lCzTwj)mCiYphagX4*ih=8@iLAo4@fMPc$=(_e6Q8Oc zfMR3Rd+=CNI6PW1p}2K;t}Y}^xxvutQoXoWQY+mQtdfO{UA40t#h8}t%+i#5XIqUa zq}BZhYX(b#J6jksytx)}GN~v+=Na%_$*Q2F!D^1ua_jd!0J8z#j5t#yHb;FQHvf|` zdO((unS+UYR~$G1bH{4U80yqRvT|-w(5mXj&XuryH?~bN zsa|mz@IoGt+#DifjFZ)()}8g+zCU?Qn`9w0gth(ES)m<9I~b>3_Rt=~5iPS>gm~R% z$dQvOU9tp0(TPcCD52vv9#88*mj|ywvZPi3r+Q%ti^R#^9tCst6U<}<_1ekCI5`Ls zd)i8qlUga=5N!(uF zp65AMM;0|BA_CFOwM_I>kj%8xbUh(NR#0802}0-Q5F)dT?adgcFsWE}OLEF4lXDh4 z``EWYxs2W?Fw^hs`%Sm_d%H%L>UD$Z8r$Ep1MD|S_28{*oboPkdXGx=c3Gx(GyZ7i z5Iet%Tk|;Jet&F_@8dhT4P9=II7z&Lq67eeW)7j2MNS%wlfS@y?M~HS*x=4=Wv+2@ z24D_s=U^t+o=f#AZVA_@|LT&xP730WzXkc0mYqDn5=@Oy{M>jbU}qFEi4#>>x~WI?dz{pzO_-Bd0uSaZUEQ+Q zOczoUte(Uyu05OI>Iuqg3!>`K`ErZC!~&GVEfNh~m`nS*-DxnV>0WI{sU;OZ5@wYlmE zm7b`5*-84%J&d}6@ zkcb+9uT(YXwpc$3Z~v~wE}AqhyK`C04MFM*RFdENFeBNG z?=qHr2(?vB1iYZ1mh(EIFi|*>H7G1~LGVzjc)d@W87Kd1u&P;#h5 zZWKXv+&Qk#y_6_Ehrk&pPwa^*gHtT64Z!*oRb_kaGIiOLrtQ3rs9KGaxD?c#8da5L zXL7yU>)U){_2aL`@lsek%m)zKSz!HU+^?KEbfU?0j8FL;Wvk9#d5;1od5=i- zqA%SU#>wB9kEMF=kL@vVdIz_m@0ufy;uhoB%S%)}OC4;Ag^iOJCTA(s01qB0D}V}v z&hAW2vZ2--)@qzAn7gP?@w7h20jnm<0-9V()Q;FBRvHa*3ncYoXP3aWO!E9{k8EE^ z4x`4&k3s}Gk!i1W&ZLP4F(hNSQt6SJjM2yu{wrG3Y(t&Q{GeoYr>RO(;o`XOgOS~_ z%YuwCSx=Q65sGE;TuO&CIvT(U%=wOBN4)M!@?5O!*OZ8+#Fa$}#_1tIrs^z*QoK$i zX=SZLtNjXQa6;NKa@5nflyD9rywXhKT^k`NSmzg7AWuk*JkXEhMKClq>skf1%)7uW zA9YqTOc+|7m31EVv2y8L>RR0#Kra36uG>5{BMB%OPZY#_^Q^uzd1WV?Y;2kxFMG{k zO`Tn*sI!6&DqAnA9+=z;Ka-+vLd-Tg6&nZjX09fE6}B0q3fXH6Ho0$E#gN1X;}lI# z1CWMkLRIH}YHi7kj?teJKTikM7I)4}?wMFY5?!9?x~*g6$&cH&bzqk2OC&Dg`=vHE>L zD#Pg|mjoJT?c7v=Ze)g8_;uJ?xE}Tq z#eq{c87GQrZ=f`cIhgYg6$|Pu{kQH#6kS)wTcRgG~HgxjYk)oZS=4>L}|wv~~AdPb@T zQFG$6Sc@@KB6MjmS3P-iSG|XUQ~)QdH;OSmYYt&GP8m{uTSvWi4dBzopD$J0f3nsK zpytNJoP61>af0uTae7-e>|M0&y6U~FrF#C~-K1TBsCV&cKiL@lkJ9wk#!nEsJb@@v>MR@WV;2Fg!#)f6R1E+)n6)wW+8+1Ar2{M#nmE2PFaby`TJqVCoZb#Zpa zF`mxO1k>S-Jp(i=Vlg?@?^V>uIlB_lK7iEIR|htEHlq*^l#uxzMvV{9dPCK=%&0Rg zgV)hW%S!ikYK&9uJDY!A5MQ%{E|(e=&l1dxlg+SPCclpX5^LMP%|#DHQwPB~NpADb zh*!&gOAS{&ahE$Ytw6H(fP(cfw0<$-k7EGO#yB(4eRSQ%SWssP=V=A5VolKc#` zftb?RvyhVRN-)#Td<(`U%poEAH@7dH@QWeqc<_Wr|o6UY$^_?xLt|Y#V$Mlj_Y9X&8OI$js&tx&u1$g^Ns2 zKjpX5o^|3~pp~4G)%ZoS4Q1JzRPWB_4wg7@k3@ftt!__dsa_4K-dW((Rzp=v9l>Ss zXKI{?XXPwVdKgIUb$hl?m!vA%WXy9Pr;zG>8$FzCXMX+<)i|XLd6;WZgN=$LO|v7n zKaX$Ys&{5U+6BJ->AhRFU67aF#enb8HBM*$_IP`5Z||YU=KZ(joatHu--D0_3e=@% z%q)cplN%u}cU<+JT)fH$FMqx5L$q2w0sj7sgq&o$lfr7d#^UDeK@Nmtk9{urc~p{Y ziTa4-$1a``7Hl!=yNRXDKrX6;EU=C&u5FF6KwTaY+1UAoV8FsN$PVUG>7kkw&w2-W z5UF$VzJa-FeTJ%lR_;mRUYcSg5Ec56?4;DrL+!vOIdi}lHAFPS0|SJXU!Qv&O(}U@ z5#CoSYLsX}tf-qFh*_jtT~#s0iC`DOj4lPOR>KyKV|Fb2OjjqQT8)!pz^N5CGaDVu z)gFL$G0IJ1*xVbLgFLC~EKv$bXDnN_F)2B_tDSu-=2;udQrl6Z7ATz7BDn18f~d)g zn4l}p7KynXRtHWX)J|YWGFNq{Ua!qD>#t=-4AJMwgpdY4)n!2T_r&DvMAzKO6h*W1 z5AFRXW(J{Fzw#7;hH)VXTYsWMbbp3C)YjO zOKT7gYq2`3T+g*NFGmoqE`-wn*D+6&O`hVWqQU;;tJHdzrNZiAiUR@{onq z9hutlhd+gMgAYq})+b>-F3iAT@)avw$yVLU*7aC_gK^SIQIl++Wt_IH#%a_!0Wh~+ zs1&WFsBy{zrIxp>ae6bx$r|7qwR{C-OVPT{KOz{$Tq zz29B+d|pYC_l6z$&hKW%>D_zYkGF4sdkmc3!7b-Z=XT8A7{y+S@xmn{TsMkP@owan z`HUCzwY^u^U!1a9n*P62%yG+^fYbuUM4pu8WD=c_LM8QrZhv_je zY6Bz+Z?PcF0vxw;Mi7_TAOV9E+#o=ys9KgXOfYHyC$bNLc#Njx+L=@@nsi1mS93GY zt}aC^A|5zeNOY2noly@8I}e}=2_!;myN>4YXCp%drRqRU!Y1ACO$A1BYs#Bz@){(Q z@>GIBu%KW}Cb1KTJZ>~^4Ja|1ze_P%Az-p5yNw0ZV(f~{-2}vg`t0{S7_!=;xQ_WO zEU*qx8lXfK!Z&ql0fQnn(H9G#YLdn}%*VC46+vobNV68q3f%%xZDTYLs4}wggZDww zB$O1vVcrQAarRG{)UI1x+LXNZELF?)YYN~r8?0DOkq7QOj8m1UH#0D<$*O@;8#g~L zZj+v7souI9?A~j#roP(Eu7r|Za$7mf2Q0gD?600dQC?cU#%&oHvw`DIN1GABI5}%+ zHBNJ)!LHTjLnU0z=AaOaak7|RjGa(OsrW3j{Z8bBIiF z1Pg#wyoO5&4oI9bU%N!tcIB*j-m)w0!;?v#V&ERp}7{5<(NRHDD0 zwscXrlnRifYk~eQaEb=Fp1QKrEcX1T9pDwrA$1~$C`etZhb671?QFfiu^IK6{g&Y3>> z!XAv1%c+ujuN_YUdpRpxhY5M70dDr%ndA;ro8xOwkBz%aMtSEVmv+LK37;!3(aUEdZ{F5+7feMtu=Ze z6-buZwLeJHnA?j~8(Y%Ylw#n`7!sv-nd4l05DZMz8rZo;#!~9kf=&a5u9_DMq__0# z+&i`Nw7}ayoYh`fpP(@p1ar_ss=EW4gi%8N;MoEOZ+)?J;*#WIqb9K868U!s;M z`5f}!tM)D-a)5-mRL?_hmz1>zxWtWeRz}_JDra_U7qZcnUVA}nMl53UGUi%o<^kD2 zrAAhI{$2w~$)t}`qsB>^oY1U0W>B}#rF$nRdGcnn(m5!sEzoTJUI0x!=;#cA*%QQA z*HoDuBJGy}e79oZ@m%B7al*oSj@1dXjJ9)_qQ*%)92H|2s;c!ub0wQ#MlUv(AY2{= zt8r4Y1+6xHeM~LcV8F?1%G_0Nk{(6<**3OF#3YL|BjeIU-TKoxP|8kYRv+DxOb#~J z#Z_w5uPDvkOH=Y|R0s3YB#X8`1N4$y5?f-f1{jC{Ltz?NV2m4s62=&@w<^L~3>c)k zBwk_3lMRBoyhWHV0(%r{mv*FjJ~sr&8)vG;>ZzFJhP4##aS;W6a5M48r-A2drLdTr zT(_|Z;N)}8lL&TI5xN(Wbd6cJd+Td)wpE^5Nsi)b^ulsB$es`1pQ_h5fl}C(08UWL z?5bzR7|z-PdD=Fqo*-1a@3#!VhTT&!3)<_~);^3fh?HO2{<8K;oy zrOdY0wtic`bem~K!|=#l^@|M6Kq@duxNr%&ZAx0peXvLk=YIK4l% z$H3_w+-9ksG=S3HkXS8;gyco6DeT7Oa$TCuA+m(#*`-&yu(}^{;8deX->kbu)B%oX zVli?6@I83!B(54p7(rh-5^Q zT~8nsok65{1{Z*u=mT7Ozn_rmSzcbq9zM4#vvqTplp-B@KyZwN zJkU28p#@qMnBAwWhRWtsfY%g3tB;GZIv&*R*pX`yQgH?=nfp}$qAcp&>)L8SNl7?MH{Sjr3_L*gUOl1%Q36|QenwRwA>iQiLxkf-Z4RA4Apv(uz{QX1ow zt7WzgGxi8Ou6q8QC{R0d*}~b^q;Ul>CChS0O~aHr?$pbB#RRl9WruO{ zc~_YbsbrsDHvXPiQl&~^lF`Plo@>_?miyM**pd~hUK>W`bhpMS`e@~?10W%q6Wenl zC=>Vf5KtDJvhQ=durMc22Y$h9TNqvDHJh_Z2mx~H<~21%jZNRgRG_)) z#q}vnj%;(%7RXms=sMKx$vf%X7QH}q<$zXHmAzrl3~=g%H-rMLo^12oU6JqpAU?piN*>5L)7dn}IchTMSpyLFpuoaWz!jPpH&Qy*_{vAw%z z;QM^bIWwfQQoU%bXu))9FXoCcrp|Te3QPoX5Lsx6x+5LPJ1?Ke6;{GtTN@Bks|F{c z=cq+#L9;}W_slqzRGo1$`9u{#H0peWtd+^-b`3bi{!;Qdqnhpct^_2c29gLln*pkX z)ab{A142J9&9lohrwfW1Uh1Z3t`7jmI9CFLF{C@^e~SWat(GC30M z$ZnQUBn%F052+?ng{-N8xTq5%@j3L zVac32mk`qCp2YN5eE%LMd*B~{B5c@;%T--4#X;Ri5f&wEz31L1>eeA9)eF#(95~r| z%?+EC%|a=QjzCk_uoJwLI=hy4=3XL^QX(ajan>n-gay5|%}4`lk`$FSsFKv`VshG& zazXly&!-7eC423jNHEgoFPMmzTS$tPO`2k(6Cd+LA0q zFrX6CG{!}wv1?!;q^4{jKns$r9RvzPH_+w5?roh~WD>xsN%e54p6bjvHFJounL})= zjVsJ88Y;?EC#!EnNYcN-RqqXU; zdhj&4+%5n}77JS4Lc)SyDQJbN((Gz&U}pKA_$#-cPPlUPTC=l8+$_P5IqfiD3CQX- zGE$iw5P>hGk_cBlbF@?6Wui43)!0)oLiTfHuKS|SIOTaPoBy&tG>0O5>}-xih^pqE z73g-T9pV7hzUhG0fm>1sL6|{=W$kUaybd3L+$3nY^w4B6RXPvi`^GZF_<<3wqFxV@ zV7%JIMpL?9Ob%w86|FtiCA8L^vNxW1NI3XL22haIE^gQh>g4^yIPy zGrN+k$;T=Jr7`y{h)(LAlHx@vi344?fX{5t?HMV$btg<4U+vsJ#S<8%+T0Lv=RHGk zG4m~PAc9rtnbme7v1Jt#*KdjisX}Q|J?k?SftNC-EfujELceh#+byE>4Ss;sLg~Dg zF&HPmR*{hEI&i9`fg#UTcwz>m?7nuQ=Fa9;jXX{|_6ZWQ*okGoK|6C!bZZB@MtdaZ z+5&%uj5V?`6DsR8wRwkwO_4PXy~}Of9G;T z9Q=yS*PQxRlOtYt1JWAc)>>w%Uh(S`A)i0TaP5g5kmu$QCH&}83U`<0S|dmnF^d(7qL!e?hwBiV)Z zL@FsGM2(YRss=?;X6cS~wN7naJU5(c^CYBtVGdCnHDwHhbYof;>%{+Bsef4G-Z0O~jG zm+bO*6T;eKk2RNV``qlZAJz-jHrp`7bkYisac8}=;$=^&%rKv_m~1Q zI!&x2Zrin5j~77tDQB`Rhsl;n^OZ$DpAwp`FXLRAw`hqz)7mK z7x_*k?9vwKbRrcqnW%!*w@5GrcIDx=7O&AL{g$2o!{P0Erh~ zKoIeQgk+9vCyL{c$i#_nag)%tJ9giyZ`ECwz4u!GIe%lEhcU))&b9Zhc2#wCDrv82 z+1|DHTL1sN{N|kFJHD5(O0az8_>#ZZtUX2E4Y)>^-F4H~PAJf3Lch;9*fL$buO&;4>Y)Px8Ae5`2?|D=_?TE=V;1dFT% z$I?$op3}X6*OKZ9ppU2O1>=-=UN$NupKCI&xIo2di}2g@AMpN*FY$D{4*78cC(Gxt z0;z7LjVpNg3aZMwJk4g%d`-qlP%Ndz;nN!!S|KmgwNT8*Eb=#;b6(Rf0oD@j&e?qN zZ#~~Z#!S^q_DHmI*#eZT<9gld}CTwM2+9G=5VGKz1`I34!mpHPp} zKPg+KLPCs22#IL@+wJzPu-yWu_jtQl@-|CWProrg)Qo& zwPZ3vdzb&nI2AJx%tjQyvCo3jeV0Cl&qen*a>9d+?ka3=R&9>P_O5n1&5M^Jk z$z3+FsZ#TgOoYwK(-P&?4D^7EXOBW~Q+U2#PsRz9Mb}^ma)@V}1B6q~MHKfwZ-_?Q zHukHKp)QRHmZO+6P_SA*d2iJ{SH|>o#i98g&GI-U_$ z04-#<5R6mz+ABdAxU|V)>WHR|sUp(yUdU8E_Zc*z1dBYwA*|Xv1?>-}_Le6~?@y^; zUO=9E?gQ!hAetE%;vrp*doqho+1cS`kj1?BE4sDPWWFlKtyVe)1XPb zJ343Foh1`O#VWL;R;kQk&TMCR_|+IV+n-_GEE%T-Bc6*>swWz$b8d*q1S+Zx8|z%J zhQ!P#f^iaT`m+3x^tQAm7-ipf#wo)gq;)QP%+1;Z^biJmqn+ zJyq}QJ8+VGhPpdu*R{;iw~(qA$CSzgUFN$~3(UA5qB{vfRfw3d=9}C#V9?RtoP(OPWzvqaJaYIH@F>7_3&y9<+JdXar&0nZf~3S zc)PRYLsj2 zF&*X!RbjrTHML5LYtd5^C%dc)-mpou6~2%!;bff3&_8mJ zV|4!;YD}r#Sq_X-7V4zLX2^zT=T)0)1l>DEhoT9uy@s&4iFuzU8b!O zg`>kPz#*fx-49Z|031SsZP|g@@M1NxD9HVb0EqGi62Mf-<7C;bt?2hiH*|s34nPpY zEc^-hG4k6PO}N{)42SRl#mSJ=u-^hsBf&1d7g@n@DOkianC{FR35dj;zCO&<#YY$? zm~*oVFi*xwgfsULDOr`q?>hN+$x4@0ucSS)VhE?~de{U?!O-*^8Gu*MKF^;6qXv;y z9C=7l%jdYCQ;p}8SlL_lHJKkiyXcaqRNt7zqe~pk-Mh~QxbW!oJ8SqZ^BUB%aQNPe zNPI|L#XTUx7+OBBoCW1F87FseAE*U;cqPx}GgLE_$Mv4D`qxj)&{J3O(S^6l0nlOjMJ%|7~1d|0FhEf2Wg#CyTl3LRLPHb z``rL5zK26NkEH57fpOaGCU7FJ%@`Hc9&?t;<5Ym@>oHCx(~A#n*(BKKIIZpz2yW65 z^zEhU+5YDVoJ8T`S-5yQJ9T6Jn;clA0!Hg2;Sggy4xDa)rQ1UOUEd-VIO{3*8|ixO z_H=(sY`4JaJ>D*QT3*$;zg*2&XDtuV;e~0*nrtc2Qt^;RK!UAZtKSaA$m~1oUc@Uv zPuYj&NLOL950XW904GVtDGJsYfIDXQJ1dhOfh)41)?0T20L{8h6$hccmP0BFZdLaN72#!0D^zFMn0lOlM4 zU6+v82`SZ!gveM~p5L9nr72-EA*TpUMp7-LdRqpEl+biCP8Rzc(By-{_tR*5*Q#k8_VMygg{KW=H9+eU2)4ea<$1Iij#X7pSemhPNM)?GF+03 z)4WCj)Q0HZAlY_brb^V-mdC0-4qzx46{&EDL#ke_uV7v%MJ?X$&u78j(qN)4%L1JQ zPNKU!cEqKdSGAs@4t!~OEq=ydizkR1TY8nc&6phm^BO+lI9}t!2ynHW^7#^tt$7^9 z)aP0asb1{&{!I5s)tkWSW~!bO;Sd2ZeU2wW1|@s88UB&LNhE<&J^zEXg8jbM*SDbLdwlRO;rU%D^CN?==yzL`ljoNMsUx2H2DGF<$I!ZK zRr)#e0q!5XHOpmr;No2Ec<(1fUM)wfusLoPHSVr=9&k(j^k5W3MNHjwTWEH*Gl8CO zxC6HEzY>L(9JviE<@eO@3_&)*RNVh)KgsL=-0g_|)VuSeB#RlhO(x9{Lz;)UPTgh; zrbeRhNAzn-g3JAs4)am&6vD(#oP}*+gJ&3xFz`#V0h>@|n!F43v3acO&&wNfVCu6LoC_S~$*IbD{cM`u0uiI=G*Rd?4v-G@ zsH;_VI~lWGKR+Lnyg@|vE$G>jno7R01E-(-+xB)J zA(50uf~IS%*}yC!oS9UfK~rc}Z_G=gnTt|HGn*E>KD>p+gf`!&lbo>W3=7c$Wqmxk zPWFkJmfr?-z?D-0%pZ-S*0{gTxE7p(>_ug0bwmWx5V&BRoO zK(#+5k!4PT!qy!eRm2fJ^#UhN{MmqL z-ZOZ+w|~Y&dOtcfG05FXGoc=yIPw>%zO%;aY!9DA5 z;LVL$&ljDy%;3oPQ?X|V`SbJpPTvFjgUvLaRfmkNkkQ1#n3`Yvl zYznp%g`L)F7>(9ALo^;k08qgf&o);fu8=Wdfe~ZI%%hh#ib)qYL@!Y$h1`HP4Y`8H z)@?xniYznB229u4v@KwQ;$zF;f7wVfq=fjm{-zl%YnFYp^TYqQUFGBPx=t*}gANur zv`B7*)5HH`d63vwDCyojq<8p-w$zwRoQ?NRa|YjV-ApV3fK4T>c+g*RX>-iJ+%&!> zCT5Mcom1l@h?*f6R;{b9VIy@N>Ys9AnBdq%hb`O7jX%}Wb~`nFr>Ue>RwbPQB*x(} zK{WDd`;i<;3AaKxpteAaptW?Yk9$M1)mCZ^kQ8LDILb@rc+0oLFQgiX_v@Q|i9joQ zK0O{v(;Yv78Bb40-#W+{)sT z*gTusoTE1b+eDO3(KvhKE}hDmCJM_W;PhD4t-)e00_n%P1GMPYR&Ivpge^JmqSoO^vhHsM1xHSTAUFQv5OCKQNC78wGiv=FXanlw5x z36vw=m&8+Eqy%g_l-L zH!xw_Gjq%^iF6ZTV3SwiyB_mKgVP-yP={!k)B?qFt0vqDAgSIPFEu2UetdKK!{o9- zm%xR2X2iqug!Du2cPsLWr>?HR?32h%=EAEnmk$)y{eRM2Pn<(%Q(qBoEh>%P%tQX> zNw+s!xLg9Exkel4m4&Al@%p33`AwPGwmu{Fsc!qLH?Oq~Jv3Xl|Ct)UT#3DnQ9M73 zUCX|G2!4h7#X0*_1XVj!F=Ua8BIxZaoF!<|F^PBIvPI|AEz4^sY4k8=Ws*wBS;lY* z?MVs|L!%j|@tJ93@dTC+uOe8Zk6pv$*d^VP<}*&1;Lyt%LUFTB6V6 zK>*31O5T$%X)+|DMdu7A8Aj=bm6`#dUrQik?u$Y$J^)iZYJRNk-M_FoYCm`q#02j@ zTfsEWEx3oq)gFzO{K!6_R*p7i-d{JtWIso!q6ovyaLBp;#Gb5Ki+rC;N>uJQc@%N` z4=+j9{dMHR01~UF`{x;ka3)RYb3!cS?jYKII_AzG)}J2X-yurkj*=ODRz-~(EzwSF z9nwP}F=o0$6-pDpKP&`ZMI?Es+q8+aKZ=^kQ_4O`Gs5KSa;7C_bO%R)NgON}b9ztR zV6fcO^MLs1XdTQv@@?39(`y}0V(_Qn#f_;nBkFVA$O=I_;vY-9UhfJy4D|{M>RyFGkd`@pm&!06UL#LZ}lX zn!i4Y3nmWOpn5%$x?KdOHl7S*B?lZ-DsH4h>HW;)-67HaUYS=nswSY)?Y0A#sfLsR)j0(9-zWyLvY~ObE)2Q0O0BKa|B&4q@<#)q?T1x$9T>W=QD}W*Sn}J&UTd9$py_+K4D8wPxBa}}8j{JOzMXaAWRFaY&_|?Vj#!L2rLqjPt zMbb7PNS2}D`i4p1W#*QT#WiO0>Q}e?k<6^EinNC+u}@$fw)Bxn>NY?~YX*k4x;94D z17dpC`oBdMHziB7p<;Dmx_}+`KF};%pdT;qS zHyUkO{kElJ@|IjW7L8Hj6fiXtyEsc`P(s$DMUIt-;S|WD{AG^ZL`pauD->lxnQxXb z&E6lgNAL}1s+eQOwFJlobDlS)S>uVbm-TKd=#PcxJYqf2i8#OGUVvy<3B1;8@wZ@tM0A8mUF{iHVA3tIp3uwmq_8BylQ_xR8?pm5y)>C?q+Lnu#2U~!5oHNZ5 z+=30^v_8W^(4r{=$VyvoSgrfLD+{GeDXQ6W){f(=T|S_XRyww^#5|?Ct{g&Anmr^XBt2=-0%D9deJh<9O18w8Ie{yCb-Jy4h^F04UWr^F?xJ_seTip&1 zx|TI#+q6e2i8C`9_nmom$yl(A z;*ul!YF(yh3de*qx!6GHV}FCRfcWs`MSmtJwz$etuWLFRO&}kIm_>vTfZUg)qmUc! zkN&Flv_SBOJRtKfAYC4d$*F9RD&t(D*(^|F_(=V{>m(yK)8m+N0oB|O1j#&cKJ=YW znE1!0*q*~wydNQ7Y2=d`Q%$$Pp6J-vSdFa@i?W{TR$x4uW4OSG*Ia#~4|3+0sfO(h z(ewd%7>is=4I%|{UZ#8CB3Qp1IZePrTpe~6lPY%>VvuZyG z-%Y~Y*nEk1aA^zol^SX!@^6NAR6Zj2cXsUx6D?+a_9xBb5&-ZMF^o_!DMe0H-OpZc zu=Ua02uW78(>MEyCG%*k2<7K=CDzDc^bdgWTqH zMtHwm`rqRcLF(tgxl^ou!yxSS8)n zkLSyUG9iQE^`qBMw!=Q6Rq4VDV}Bo!=&cQmzSqU&C+9bsWaoEq@O9B8`}^cOSKm{0 z-vq@2TreP{?^@>#<$eDBR_v@!couK9spu^{6lQ5R3=L)c`NNqkIKYm=~!jt-$CMHw^S zU`a}UnZnRY7&h#s95|mz9qiQ+N?39BW${ff>>E`0%i9%xqz8M>hWaWjTWqToyR)kT zanm6#eDZ1r>MTreq86e=r(~E*e-{=Jp1=8J)BKrzGd&V{gV-$1A+vG9R0R*mO%aYN z09B@(L7~WynTb}D;1_Q%4Ga1mC+bH6Wf``~!ILIM`d{Gjx_4zF8}a4TC4D4tmXvJZ za-90iqdHs`XPWB-fdHi)6BC?k{zl^pt>&FD5reCVunEZ&@aPYO?JG`1CNR2kKEJoX z3^WyAG*L|X`qkPa+d&~CcRqRFKa`25#+MHk)EZ!e6rx^TEKE3m?tCADbjzv1thJ@) zruKt?G&xv^OGOG8L7t;uxjliDoF0EDqV;#qeKc>z8m1r7;158#{!6HV2A6eU*d|#i z{gK=jkA>3cJ`YzUge5}?n?iG1bDNAN{eD>C6Vq4grynW6b3;3WjS0X(eg&r81_4;> zsh?dt%UTp+>2ho5qOlb-ih_$os1Sy7Be9L}4n;Gz7})J}wPqWexh}GU8zAP5b;aj{ z_T(vX?OUfmV{vbYtz1Q!tKUM>HTIr{J16BN=Sqr-C^vrd@vt7d*~hHn?;S}(x_{}( zh?8Yi;fEFr&}HsU41!A@sOEz*DG3UAMc>PtrwH?h3g!4Z!S=~Gkjb1RmyZDL%>p!4 z&I8QTO_R*qeQaLF$5EIC14Wofi+9Em#$^1oQ2FeKt{>f(RboV^{_1_E9xx|=KR_A< zJ1X2!8&HdSo9l4@Zgz%+8glq1mXz6BCtOJ-&tnFUVcv+`_eEohy>35xyAg)4L|6oQ zejWQ}ex-yRXg_j&>LV;(Rk2_(t{ccZcC0L{0^MS*3)czt{iQp#lVsmiNA~G@rC)u& z>GXebHhv)%yJ>wE&SYw7hwh#W&d6Fx-Xepyjkkhdjo)>G_H}|HgYP$Ay&o~(!rwz6 z0SDYKd#Z1={~MfpC%YbMyDE)--H0U6vt-QSjudkjKvc(c{qcOD^JlbVh6R`o3G3vK zW^IItTTGpc54%^NBwlG=S>pO7F!GjO_J^Mr#Cu(Syhr$jg^mi_xCEfUo4qI5`v>GE z3XH-i_ciWGqR}`YMkGd-ORYL=PA49(?B*fX;A5v)I^XWsET(joDJxEBEO`_H6WNwX;7Y+VUWJKjK0F3)iN`^=K}#c}sV|eO$LVi(#P$VCX-kIxu?tz{5WyKrj_*-1UIQ-p&}&O{g}cMuJDhnSSW*F1T5$wJtRsa6WQM+hNYs>b=gd%iEi3v6&?(=Ai>}NA0n&f`0R0A<` zHxXB$Zb?oVX?ZkYHuV#*|G2n$m*Z88D8F=7kv zVuNV^YIwKV$W#ZBocfpNhf}P6np1#Cd$6mkSAUIZfoe zd>dOhm9Q)z!&s}b94n(m<;34?;cDOb;rUi)w@^#BTuT+VV1;m53#>^)JdI2#9PpfX zL<~vDLs%L%X%SJgX+ne1GPjf1fKlyXuS*9VnK^tI3V%d?^KbBzSz@r)yAO{s>8&_H zCmHxfrT&fK2lakwtLIrtFKaU|Q3ZT`43r?9N&;RL)!p*g~y3^3w0Qj`2% zTRkk=YDfu~K5qfi;`xVO_yJTXATo3>`rgBD>Bwtl(zM~Ln&i_~hZD3nuYV2PHxk`( z zkRLnMwH<}c1bgQfNNZ$iJu~3jn#`8nGurLMSWgKWA#3XBv*uT)M-TUr_-cP2+0HcPi$$EfNa{=NgS z56oP-g;}Nm`$#Iapk9TAcwK%3Pbp%0LGfm~kPqciomIP{KL$lDD@RnmhAHg?p|){G zpIE8WAS%LCu+mEFm1CwQn8K6%4vJ#8w-9IN&J%Vq0I(_3Tbrz1!K%P6@8yuTUbvoz zy(lDiW{VQ!20O-zrR4HDQSb zu5JNbDhPl(WH=WXy}tB*+x*kalvoe=N$-mF-0VQu+@aIz6|Yg-&rim-sPP|`B1&I* z>V3FWm{v7Kpcs{HK28sV{9R#7rdB=WW0-p+2Wu3z^PIqUXSOf(Mp#Id!QSgB^+q3KjMU7E{3*`gY_O zQQp-9R6R*$&a-d<-@2&F{i`-$gay0C9>UB|Q7Ue?3$1t+r2L>)1jy zxfrz7SOJSBN|5YjCWvPPKJ^siwI#5S`{_8g`Xw5a;pM;~E|~C7LAL_h=01&osIUE~s;@^sgsoYP5-7 zyt{muD%Qq@5{l~=zwI{q3SSMZcMK)p{MZ!7Byu0n{dv|x|aY% z7KW(k^p|M>l#0mUk=tABC~;xOdR~kmQhHK(WYMOzsVDD28iM-khR4A?-n4(2(O19H z52@1V#Tro2A)V$bD0k=N17-ePV2>V8YurH(`6sV>{Kj-L zTp{*)3@!8KqF2`7Yv_~zhnp7EDP$i-MOV>MY;pNKjp*3A)$t4HqZ+oVCrGK-v13t5 zagpqDjDcs*C>N@E$k+jRP}w+^{v%(_LsSYd7S#@}z}8+(1#4+E>-mqvWSwtrlVw;| zjKp|Fv=5>&sbE|onK(>p)(t28{jY=MxLAD1jA=;KHSo)4QGq?&vi-fqAtvHVAS3`bq#+0lDD& zr+#K~vV-GwTyZF=qc9;$K0^L$Iy{1>ktH9yLDJu*Ut$>*RD=~G`z}{d@Ex08O*vvj zRt|Li!GcRA64#ClQBr0^1!u@#Tp$?@_ZMqk_4a4H(3^m+(XB(^!!lN7m}`?G#=)_; z(rwREoC%a{@J)*bg|{`L&?tfAxY^a?6oRZ1`{*PWw!iN03kOVuSHY1ip1dIJ*T!)k zy;1J@CmLi(-26Ei0c)gP8%LinBX5Lq8y5RuAmN-Xfw_iG_x#U2SVyLv($Z>~&8l?l z*oC#RiznXSBvmA&tkmzSdnTDID{a*d{#2uf4Cvc{V#M3|jaiN)hNK$0*D5>tB3W5U zL99fIa{VXSHoMa&D(GjzZdzd>scFaepOoasiH9homniee_F+<7Mv;=k=fh8+1WnlJ zF`|mewF*yI1Z>mlfl&G4xCzdFkcrn&&R#nL5b56~a z6kXegRFg6kAT}hld$~t(l!-7;Fm1VJ=96MqQOf$h{PNDAS7PothrL8k6TRsl^M|908@k7T0kr1n|D0KZ$spIR@Jd7wgR6*5$ z85ucFHKmHW#bdJEua7~nfRZvZm=5SfrLhof_Ms86gzg!Pvdu(r90VD&JDnuP`Af2p z4~lht{wej-QLjf2W_<0Ozl~7H|Bkkoi-Or5MI{skqJ73TWiUc;Gmy_foTG+u_HsKM zoEq#2qxho}!*XB`dq@W4O*TPwqt|(G4?|xW32)pgwF>(94ZEU!o&BRS(&r(5%eFnr z6$?DgDgwe~TfGon90xjRr*sVU4m$X#{F6|&Bg;NdsA3lQH^_>vzA|f?wf>P_(I6Qc zE*Slf9zcMg+_(|NPtE4zL9sw|xwcMN3UUWoQ9}AzJ4V_R=nOnXM}t2ivgd9UmPdJfjK)pb90`~3+yO~$W1therHO2RUv&BHn6JETg9HjKE0KX;}Ao>q7 zKi9BvoFjE4C4UzY^)xC_(xo3}ow|1rNdo7x8#Ln*!-`R%<-7*3qA2Z`%$u`jfV65F z>S_B@=lm=(Zn(YS#=fKs?Pi97%NU@Riv&&iFO5u()y0cdDoa2d%S5Sko#YR>=mc2o2&+_PEU(p{kJ zuR03mSP~#IT4cHh69pX+m>aHzm z#zIOhjFg`t#Uzd+L-OTPdZ6lg6LxJI=fP@W~iu#d``e4Hc>X7B-B0eYEZ5GPV zlw^yzxr$VqDR(bbmiM#|B#zKLO~;~5%|5LIy)W^hu@Uvu+~-FaKNmREVR*IIQE_Mq z(;h?{+7#n|!?$K=#YtEF3mCA4t#GMd)6aZXeE6Q%p0ZE*@q^C~ZRZzGN%UeC=bpyj zCbPnmg;S9~O`V#7WV&)KI3sdRvT#}34!rqt2*UB_aYkN8ZS=h^G79=p);}{8PnSUE z8A{sncOA5Y%Pf~e+!&N7dr5Pey}KXG1YsmY@MYZr9-zPLyT3(9$*pZO*Agn}v8pld z@aK4oZGZ8Eq;KWeam65~&Q*uu*4P@Mm2t-e)|d`-%;(vO^nf4Nu-seGi})Epoigjd zL{U_pAudO5)5g;Kaq}cxoCM90ROdtv^wg=_?z9mgU9-LW%XRk!U8rvXX0w~>dH%tb zGA-kl0}y){hbg4->G!`}V=T9oz?c5n-MwvdJGS7c9!fHlXrI?hARYIQ5&E;|^4jku z(-5zATDHGQl%IRfcFBZ8H3L&x48pUnHt>~_`Sx$80v8pB-Y!Hhipq{HNXd@$jQZ0E zQIvVK;35PEjGxXfLpNh#d+u}cX&Yi?Y{uQ>K@`jM$ZaR-3Pl^fVVFzYWC(m`^j zy;U~`$cW4|8_u$bijQ2L=-b?w?|J7TMqe)EhQSZykbTl>iOA)U?z)nKlFOK^({=3n zbbi>Ie-U)v(2u|S8g8ytUZjwx%lxUbsqqaOI-J^h-51Zb5*x) zv+no3{FmDOYp-OD{my$f5?9X**EVL?Z%f3UN?tm}?hk$L7IY3b1JCS@cg0>X-z9@? zWrJ@GS35UR^yed`!#)DJRG4R}YD4orHF!?1RB^}Ts=QLhR%?mS&iCwy@F0!lF>f?? zfYY}0bg0kuKF`U9Qd-rREelL@$s(S7A(eVEc(G-7TUay!&c$Ol(dCXu zz}2cU@&SdpqI|P_7RI~MMZ;sX&#Yn?%nQN=kl}CgC5K-Ev7f(kY+fdGyWs0&HBrlj zRElF{Dao5mLQovvj4as8O+-S$Ijp}TJ}@C;ZxY(xCI-)@JS&35{yABBX6y>>+)R8G zE1l*M&9(reP(H?Zl>Zi3?s&k`L-WgO~&Xe*N6;*FHV%lp)~GGzu&w1 zjsc$;{4SSiUS=w&igpcV0?_JMgq;0G zI}dnw46`J3>|2st;Y}vS9>JZ>L;kY5-%|0yIe920U7cM-AH4X{7MomCLkvRofm$|M zljDf0bfqkls;mcj)WBq9zANJ~U{E;P^<9WJM36Q`Ff^7nazQDrBV(v4AsC82!2IH* zcNzR#M$sQWmkq4155D^10@<~|f1MEbJ1KMr(Q8R!;s29bFauSo|GotXhb|HunqB@I z@)|fmRPB*Mr`yEnmv<9uB^KvS3SfV7j*=XPJklg+s%}Mm+{Np+ZMC~7h3{EMv-QE* z<OnSOVVKkW`09?z}v z{dXX4r4gqJlIpT+`8?aMN7uU3#m2v+ka?&XeQ@l5DGvdM-a!mv*EC{-$uHx{m$S)1 z8QI1`xqY|UZ*yHe$(wWelY_Bre~{z9A^}oUj=n_jo!)$2(^p7^jw}xPqm@;=$WU^0 z5nosRESE}7y$wJud~?NVrKT`|q>Sd1xM`&3!++-Zn z!#oix@}6^ITVN0QfbE3bER>WOiRyexd>E`xy2Dc|GDEwx7@{2U_NB$x%-^}n46b}L z3;S7_NABMfk1oj()Qynj<*{J{iDRo-3i@L+FBv|%P)~1Wex=vS;3e`lm@5ZJKy$T+ z4g!t*Tbb2!-)dm>j+l)8F})A4miZun@P~1L*vAp{Tf|FBYt123dpr~FSygfw$}7F1 z`@ocsusfr@ObP_b+JhKWr0U(#QeQNu+qhMxN%FJC&H$i*$&87NXlhCo{u23+Vta+K zyf=Q9Q6@Uo=to;mrEWz;{-scVIvteAUKTDR)20;OhsP;i z1-ZN5gMWETyS0{A#-9a3G<}bD1Va1E>6BTrCJsf2-6!l47fCya)<27=@BDSxD5BFD zMHZMRox*$G|GCe(e|eNpYNNfSd~kSf%GD~dtJ`uA?1n87?1HL>i{{PDN z@cb`y`C-KPMH&ifUIqUzprOP45aWHc@5=eI{?-1Sc(SQ`_4$FVC)VSq0k*9|*RcE_ ztWQj)lTcgQ@N4R#9Tp&)BoZ^u+H%eOhb<|3jxUE@j{1BFk+t+u)}{fUMv*^{@_dWN z76^d5;!3y3@Vb~}-I5tf8)Eid{}hv|Ym&p!b=cgXU~6*49R6w=d@*3Z<~>clwj76m zRRMXFitYOoirccheXj3uW-uXjh89ndx&v*D6EtbdJaJcKny`q*3=OZ=p!|D_L-GpU zhmwpF84NAPoJ-PE%6zo1#Wrhi%Cr$7YU{x%(F$8liy^ zwc%bU={}25CHji@9k!`FK}BBhN1gJ_PupJyN)1uwXppZPti{rbRRl{tAG^fKz5Na} zl<@8z+T31S+1=icNAHfh-ENX}k8wH3SBnBNQ?$@WNc@T1F!7t6)DCZxKc= z^vv22QDTKslM*qk!*QGl!QwHIP-PzX!c|1_W;amvV%jEsJ!O1{M9d0>q(gYa;9W>O zHyIck@c(u#+m4zj#<#A}S0CJ=BBv<4$c1QG{3G!4!i>|erRX^z9s!~&<1aI~mmElY zY=7dk*UJ3)9`Cxsv!B?+?K{gO7j1#S{8fbNgei?>!0cP)ZbASb*pz~XlzLC`AkEa= zA1JjQy6w9GZBO&Dc1OJz1+ca2AAL{J6!2d?*#>X2krO$!*e(u%|AOR@*NXh^PBXw6 z)yo;?Bj3UBDssEan4%+1y+un#B;8k?(H)zL*FF7U{J+tRRbAz@ouU$3#fE1PqgeNF zS;qFN^^}>rjpMn>n2dVSyEBJuh$am#>p)B%T^AEi9GUO%Zbr}o(}H5eKGZ7F&o9d? zD|a0VWht>h%#XcP6KHh)K^fqrzS8bGfVoiDs`<^^9ViK7bG!KBJBItZ%Fwu!1b&!=^o885TJ5>}Q@kQzGdTh1>=fJopBv zuU1w^afX~nB#qoHKsB^%4TboEBoagGor@o@hPEd2{LM#KWG2dKQSV%1XfPM)jCRyX zv!>*5GL(=_$*NBaE?`wMcXUQv@5nxaUyYg`nxMbxp0+^S9G!)&MXG&I3PvqrqF?4o zYadlK>nPX+|9j8pXdPGP7|SKy;&{UZO%4)WIX#aeODGs|aHAipGH$|m$%ZHjdm>aq zr!is_WhaN{b7xn?GzDf(XnXEtokyyLaveAPRVk+=j0eNHm>catlD(FxKKvpocXi4f z96T>99Z+bJNOsg#ES-tqR=^nbSQm|9T+WM$156y0r?lYyGArXIeqORm+(hs-;C+M6&t#mqwS<~gVYW*a~Cbz zxgkkC`GF##nts-|fI1dz>=X+DKJ?M;y=()_%Q~i4V)s7>Dbx<`*zLrZ2L0h=f2*fp zSGhx|T_PKvh?G_5xu~61HDFnL=_XUoke75>6=Ct7Y{l1{Ko3kG^(#bZ$iOu!lYY$K@DgTAUV5Dx$f*0BZl1uOfD2v<2U zAm0@h@-@EhMvXBMR*W424R3`&bU~YriU2I~3Sy(0Zh>77nj{bdr%KnDZ5d$8_swX1 zy2tR8yaEczkNm6_&_)17B_9dLy7-ZVK)0KX#6fNO{qpnnf2m? z!Fw{vozLio&gx5*R4RYhy1E+COctE&Lh}-<-Vsau3p}&b1Sp5$Mg!UNsu;b-MDE{h zGMr0(0Y+070?6QabyWLWnu}Nf)!y0~6s0gRNy=#&YFJfa zE)zKxWbft9KP)??46bvz`B{j}(|mdP3a|ODw=|61R(|Z7M#^eOWa|vZpbOzU@>J>A2}E~hKu`}xZeLB*jq9Fy;_u2R}J=Bl0qKFZ+=f631l(=EXG zUvTpE`9qp*vssKr3#LDI{ov)OCb)|g+0thz_p58IB6l=!f8oqLjt`F*1pmb;+9Mxw zLst7DhC9~@fccm+XRw@>=>X0`e9izAi6j}od&sTTQyauiV{~@R%^?xsEmM_?HFnwx zBd>Uc!L->-x&5TVwG4aho)u_PqUH)eGaGkqa$nd=G2z7?3XopwBt-`{+j8;wqMJwJ zicSer>Q8>X1oBBM;Df{XnhR-e5ox4_rv24J1+2P!|k+4^(|y2t0S;c>Q|Ob8^` zbn|KTPh%#PP(|C+B-#YiYpCd~mid_v_t0Nw5itM+nAVVtp_D`@9@HhUn11$mhjF3W zC1$9rS6HR}t$g*&%ip`*`*!$&8yYY5zlNVZU>kL<$3MI8{{D>|N}?7U5xarBaKE(n z{af1DH+)&#P{PMw23Y@by|hBhcN|lL!~S{1YN^$Xb(wOaPG+O3t0&67P#lAAhM$qK zjR$;2EWB}U>VU%>m1m9P%+?id5%|JMnDs&K7VmsX|kPkIx#O&XK z)gM`glNmppDAJNwEe}s;7jEqyZ+;ErfyyJXlb1!#r^e4uK}$vv!cu?S{-xq7Wp^|! zb4_2cAr(oWp`gc>e7E8HER*Oo3R@~gDKRZW3?rc*uB6~TZ8rbCoi7(>`mYgP=qypy zxUdzvuFXdRE-TYo^T;LQzdjsYH?~HK0=tF8f4U>mTnpMPqM1pl`yW3o#P?)Xc@FMM z$=#g@BY@&~cfm4$LPuf|WjItO%Zb+Onwg4`k#wjknDH-HmlHmqq*g*etf{j75)B5v z-aof-9CoGYhjd{*?r^XV@)WnU)PQ)6VXdjbnzqsYdFBRb7K;Yn2*{f}{KOcz4>b{eaTk71wg{v2 z*u;qt{9#?Sfe@o)wSu{k9UlZ^<3kYdIv4MNkMKba)3!<>k;%k*hM9~DNrE7$3Z^5O zQ^gN^oBA=(l}(b%)`(@9!WxwJ>NmAZivU6y_f&BQIB{4Hk&_cv{CRRsn&*cFUHckV z)(s`F<k?UB9LkEQBoC+RkECwi0@*sT3dey^G5ddIuk*jM*AM>dd{y*T z@y^8FbBj}@V4q0wwoP%s{x;G#Ui3B}{ItF?=6pQeJ#Pu$Y|7PjPraH!m08zK$e_lj zd=4I{HO<IeBU;;L+vaN5d-@uQ=Mr&k#_nW7;0DI26RGaJ`8VyMGrBF>aXLDBy&muj?3PDE;&F+5@_Y)wu8!)A}*b)9WHFZf4VgA~9yn!7bG@Xc;o#h9g! za|+Mz$)MnU&jk3Eha`66fXM1e`%!5ggv(pcgL^aqb?+Zd`>({Tg;QgWq0$g~Z7v@0 z@U%;eY=|Z&lhqPc$@BT4?R{bKW}scRXA-*Y-3vNmF-TBK)?mz7d^jgjZ@Ga(0GxLHW%+B@Cm4;T45`C?WSf7lHrf+{0}N_1y?PBE4@> zbo=|?v-Q4CgtNRY`s6h_%qG@$=zlv#%<7E|fOLLlh?`(DHiPAWzt2##^|%Y4t~5?a z$^qybGm=GvM@=LhvaNJ&e@8dQF(?8wC9?GBy{&)|7N{M=T-b_aBQlWtgI_X{;xWrq zM6A`xr)gPZ;4hDJ@sP&W%a1kjZVM{9Sbq4^UrN(#oz;K!z1&70G|Ju!0Y)-TEOW$h zOCs2#qJt5RHja?-l_#QG;25q_0EoXcl&H}JCe6O#UyCncM_mHvSkam!|Bj9)*_Vcu zy|9XC<o%O?gzehX0_NS~m$@J*rS-_14~Ec5w5Qq^zr-J%c#^ zAl1Sa>PR(z=8MhM)eKXRH#JA+(RFhyt*;EK3-M^m&x126Ak+}XS^MbX_U$?EkY(|! zJTeWbMDu5FjeUju#5e=vXpXp?lFDb-{JFN5x^9YWQn{a1*C+ey-NEo~V#3RE;!P^q z%TiYg1XBu|hd+B|){aYNBtzVv-0GIuIFzG_2`yBlci zB>>U7bmX@20HsPh!@my~Y~tcgLQKwemoKSH=Y>Pjqw^llkK9xXEPPG~C*h5@3;1>q6;o)VXWOEkP=0c+;2^T6z^9K+{$Ze!*JhIs`HKl(JTXThqX6kuT0* z48yXe_~@?edrK=%2BA}PYbj= zD}Wh-p8Q?wh21?g$@61kZ>~XC1i`8Qt+rl%VZLHPH3M%&?t%pm7jIqf=Z)W?mJs>Q z_t96rLRTKBfo+f9KUjwI>}Ls^eE=&n<}>CU`*zSzLgy4l|MY2?%ajdt*S3w5+AO6( zsI2rMKkfDh35ofr+tOkUEhhf#YU8dh>-i>`QsmgBl%5ySJbY2V!i&vD`&!8Zku*^S z`IJHv!Rl?ZR&7rIkjVV1MBKy4I>EAD(ZLovTrePP`>F&7fl1%)S6 z(@RbS)x%p!pG#$6iWhe{-nEI)L^%I7%p$3%j7Vt4vqV`k_;fQX((Yr&vuj1C(CT{r z31}D3)&j~`O)-df(9$cStu9nD?*n5;D*&V&iN>iBd*_ zCqz6Zr2*_^ehEh#UDiM;h0p7p$q(mLl#chGYLuZ3(^<5x(UrIMh%aobUNwE#-!wox z<2PwS90ZS>D5a3TXi3Vc(B_#>G#;QRF1K3NHY7oi#qPGSj>_Zf+Ba~J$e{zRU}igi z+OmMcT{kp0&P4NR+{qno6Vdy1iUhc{;p;OChZ|c$)Gv(6GHcN&AdG5v{w4G_&)ajF zR*BZ4+Rl}t{Yko?HJn7_(@J|vDf-<9_*D27PeYuk-%~W)xoi?$i#(}g;&da-n$=BQkDc@nrw$tRkIlPEqeg%W4^V|_UVYe&hZY& zF*`|)i2Ntc2zit;qt6jzw&hd4r+;@fdJ+IjbV;*hv*cr@aLUP=0Y>OHUxK+a3@!31W#8s29{AM z-=ue$Xwer-&e!Nc#@H3TxntI@Zi8;cDEIsb0#z5fEJ09Xr?d6-jal4XvA5*+T_XD@ zg115At)<}CrN`I4_xl@jXf)=_()(TTYu)))`}My7`x+9tc&A*|s(ntV*g-uhH>#b+ zo13U8tH}Aszau|?g}ZCQs3A{$HG(>eKSbIixn#5|7_Vvp@cLL+lY)o95%$smQdGr_;?s!XLO&LW61r?hvaV(MT>Rh;205r>I;0HUnrsv-8O-&bi`E zyo)L$2@DQ5F@~GsRSYT$Tyfg;(lr7s0T_CIAX2-O|3lMT1+>+5ZM$f3cXusr4MmDO zp}4yQ3bX`@yF+oeAjRE_yE`qE;u_rD<y!jRHIvdR%&Yt;WY9k(t{+4TXmELB;BbyAKJ{{)jJX(^d znB9|$>@FyM|GTQ^sJN`%(iT5wY|CD!#S9*|zwK1T_*L7zpI;@KuA1?0fvKdTMa4;M zOcha-T*kRzIG~_6&`{Y)Sff0xeZvxk4>yk+(Hv%JaJCq4FX}LmkDHy5Dle(*z0Huu zurqbB)RTBl44OQ1}iMhubQndd>6Up%D08LZY2jd^Rt=m6`98^9;=C2NM3W!jr zxae8BSkXH$a--~}`Q$^?o*l;7e0vWdbb3->L#S)fj7dr(wfUmeAbPf-%!_HRUlO_f zZRb98X9{bBkv{GLG6wxlferp|z;${XOIq^jIsEPX`D$4FmKO&2sGX0!uYrA?UT?|x z)?CxQ`nEOR@p$OFmew;mgnzKCk6#`RskHFUj(3d=&oOOiKPvX{V&2|BgKsI}KJS`U z_F0RGxdhk|&*1&x=u*D9m4vu4XtSFDtmK8w)LkO!yPgrrMsPJc_s^TnM^{+gUxILM z)AV+fSN4>T=M0?))j#Zx6WDh4y7BB&N$%+F!O1jn|(jw-`%P(2ZB6R=>!OmKDs@g`*p7&t&G z>!TJHmb?v)4=xhmITA<;o1b%a`U7Dgo>#SvkasScekYwXyeJxw8tD#C+~=+>?PW;I zK>TSMq3zx7yWhG7ZD&H!sv%rfKWXe|1jwlvWVQ7aK2;Gx8506C8x^b=wpGC#8~ zF1pg?Y13k8_rG0#+Wi1EXsU0%&tjd$VP7T)APA*mKwlA?SE;@V)|$q1aQMbPXWtf3 z(~D%^?;8VhKDxTAO94{O?~bAU1X=bA-c~E-n$V~-czqE`XDc(g3Vhf&2F{NA%p=um zS}A2>0ElRR?6D>IvB#K995_^B0?sW;+|bdgL~IN>$#h_uP`w;l&WfwT@M-k29NF+K zQh7gxbbGJx-WN>$F#*|+#y7?nfCTC2tf~i0>Ry#ESx*5E7@@YYO?`6}x*{vvdafLDUA!Iq*UEB)Oo3kj7HyKxq$X_dSIPZC z%pLW$HZ~NdxD)G%?p(0d){Ar=MGiV|6pxAZNl+y-_^vdpf|s0}S~z5ghKAnopsKhh zRlY~CBAe_Q3evmpc8Vtr(W5SjEixNxo#Cf2CqARbr(n;M5Jlv3=-R&%)+S4iU%iVb zX2xV+`oV5c5Fh)#QMD`~f0R9pV_1fnU|-+khwgV5>~kjcZS5U7fXqS*KB`rNv!!aD zcGxAaNMRCqENGFoy%fAE@S?{2NAXh(diXxtcj61ES~)INwwy`0sn5<`$+opmk#{g6|whc8LO z9W82YDZMd>VhUaJ$_1VL>JSp@R&$!j_dcbEB$%Zs2+u@hkZaCp*5ZJ!LCnKCC|Xo5 z?ujCj_3aXSu)%WM>mv^kf4V$z(iH~$^Wh7iWO)GN{!tELVG5j`aSnK-_^mzJa)kx5U{eot97}`{#*ioQ(y7`mhA zoH;O2gr!(U-5b4qR^FE^tvDKFHu~YOE#4{xeh$_ZC&tkJG7W4^n&DM* z&B>L*5vWJjSjAPnU0_&UoyBUCqBDPC_4l^hQ8lLo>T`u?6fT|pqzCxcLt%po-zJj>*x&hX(g{m7nOj@p)aYJ3(M+LMz0St% zpEu$6%pNoU9Rd0fvtQ}&<<>w9+1W(>G}Ccm`of7elrpDLQ^i>LSP5dT96xpvNaV0L zxDyGIl<}lx4o(Ooowx+-8i{ixXrZTuLSO%JbRfd10rY6uaIjTGiIi_Go}G&7X>7!$ZC1RW`uY(Olz zyPhTcWVgoqPHeWGpT#(v4m7Y*6}9M)JGTyY(3mRUh3KShF4uTh}z^({0qS zD6p2_^~fU`+{StJzjA%$>sjfYlSnoYQa${Wpv4NF@h?X)IW4;O{RaRH`UgcnSV0gP zBXkFXf<#J=H@+3@}ES`1!qe?_N~%)PQD;CoF}HQWDG`4c?vBi z+{QbWg;W+O;|$rk{gu#o`c%sylh4DxAw#^Hniqg34~xs5VZ;%@L+YK%klH*H<>`*7 zH$bD)WHLOxBh#~g>J1@I{q6zyxA3{amh$#U`-*=uOG--n=m3oNMOxF0RtE6b8s(sO zOFV&sWZk2swk3rw41q~(4idBHAP1(bEB%KOZu{dw!rzN}0)-xv--v|<0c@KU>@?H= z2=OdO5tt;hh9(k&NW_^nwKc>72DjGdJHj^j4?W&F(nf@XkR2li+d99%D;a1NRl0jI z=M4ItfT3g3og3o^c20KDnBhGbuOiI$IhjK3zh^P@X2wGVy`x7?6Uu&R(GeL}UrngW z8zka_Rb0q2M!v9sh436IonTztYL+0Wq*VDlBZG}qx4-H*WdnN#IK#pjugua)_9d8TXg! z#HLk#rjL@-NWeHB5{aWU)~Q-f$(u=Gpc)eJLm%DY5x!6?KT#tA43K=v60sG-KeE#E+`N!vDvo&v<03LP!wizKJ<==(%ymvDI$>>;l34 zZ2>`Ir{W3FgdnD&7e^r2C?PlCoHEJd=kuF#aaqoBXBDs%;?bL`P1%4~-EfX8Fk{a= z=4n@{R~fD}VJ}=sod3}!NcN8fK?rBI3E^)?Uc)c{K0Zuxk!y&7+-9M)SL`aEQf4*E zo4>#f19^S`3y)*^8DwnKsoB6p6IgX&C0b{JMwgzxVRLF538fK5&v+=2 zg>vqCi_Vidtomj=UP2k264|3;xPd23a}DSjinRDFzZNo`CI%@>?vGUwn1_VxlhgQK z#2D_(C!8YAFVX>7ad2h&sIkc(fTN|#wUN*^FX6>>QnDcR>EV`tV()5Cj`2lUbLv<| z0WqTP2_|GcWo0r3DupM%3F5Ks+BxDm^>9bkZm!Q%TS%gfd4NCk1i^>5zV%wuv(gLS z(RBVHh724F71)b*Q#!4emW(DJ&IPRI+1k}l=$!((pWOfbyOsf&b%9U9j_gc^8!uFG zbUdY$%UNdbLT(T-G#q|kknY|6ifYmQ5=(FqjqQJw#lx5qP=aFU_Tt&T_I8RZk8S3h z;Xf9JgLnByW(|3Wt!9y*CeMGv9f8M4ik$88mXsw0Ee9Py1l6Jxhn?8VS7>}5v zfEWu1Ofm@TEOursb2@q9G^>5O7nq06<1WJWau!=lB+ofUTWOY$6Nf%+iS^UXEL&#g zy*Di6+=YRQ(}dJlxu|gjqX4XTV`eaX>S7ng?SU|dk1c<|T|HB<%{43+7ZN@`d*vOZ zdQJviv5$?Gzw_k-3h^;}otb^aL(3^rRk#WH4OArDO_lY)wX@E{fx}&g1(38|QOH{{ zdO1P@hQtHohI!O5(CCE-T%1JrY#f& zI(k8>`BQlG#LXQCarKd;8Ko`JR@hp}YMatc84kMj=15I?%2-g*O*g2hWn@JbldPy+ zjJ0OgV&Jgy>ZWj00HHT8IkLV+P%OZn?^@x>3?Jm^(gIK8Z(Gi;c_Wvy!R^kp9; zuqo1NK`Mx9b<4$ABaw7i`0_#Buj&$dOm$@Y*FhtYr8ndNHLP}8>D0rhHK!yTPc+J2 zP?`Bp>EHe!j;|un!cjn#aD-k1JTI;OBGo-6o`cbz{~55z!d$tUg-CmAf^qC&^?@VU z!Kx9)YkbBb`!>tuBdYl$b&WO*1IGc`3SVPBQNVP#TN;xbsWN7N=mh{;2-_~i1l7t=$J4=&VI2M05;v4k z;D~LM($yfjgafySw^8`QM^2L(WQB%2IHLdgMR5}sCZn?XJRllQmtbGdAH_h%qN)!X zNZ_V(e+kpP;VbP&d13g3bdrdrC)j8DxC{sEQTfLJuLf750{$*vZ4!Cp*Y+gy$&(j& z1Zzs(-rhq0M~cBZB`^=TlgLv>Q)lcU`CuazDT`>*zyegi0nW(Q;SVO3aHwQwFM}2x zTz?_~6dpLbLynf5jBb7h z*yJGV;4PdA;USTpX_Zq z+!3;i{#Y=p_$CbpGWv|S{ZINQr5TL=G6BhEk(B5s|AA(E7^jLh=BFLY4vPv)f$DO zLq$H|)|BfyvxobJsJ*WU=DTX`OxiX^cQ*GKNNeLkx|yM^%Op~;#yVa5I&0Vdx&J72 zKpHN#b(Tu>u{!EQ0~+a-RqC0-xC{M;g;9*H6H>o5|8Xyelu|hxJ>TtLmBfR_>pRp^ z2hBD>!Fm*0O+Cr)R;=Sll6e0 z{~f#n;e-b;V{lE`Sf>5jBtV)s`GL~D%Rt|gZIN^<@lNrZq1cm!_A#njMay(|gs`dO z)IUD7p7rI(;vb-kvT^~w8$x96DQgTkXE>zubN{c5{r^6S%XHCmNCLeWXGh&{5nEkkK(}jjAc{%6+FCoJgCPur@Jdz4< z&j4RangY+e&d|zCx{u=_wr`|Q6fV#b!FZxYcO@T zTQ1J=I}W$F@H7$yO_PKc-7ol0@IZHhU982=LfEAa=;=Hp`0k2mT} zjZ!2I`_m&GiH6V*w!%uU0jgZKq)`r6UbaJ4=_AKqF=C^yWm`5ajK+kwv$-leiz=(C zwc%e6pD>t7$l$Tvyi!W8;Z>@8aH5ldx2Sf1;a1+G#S_bD*2*z65@`A5_iMAhCG`}S zpph!@Y*J%0r&!4p#%7EXwxw-P>>)Z6&L)=DE2-^J-mN67OBIpptak0{i;t(?DQ3-M zZXELxw$lGgLjaDpEq3VoJd)Fa3alNGH`>DWAp}c;sp%j=_`X+u&jZ%!*`f5q&Obs1 z)xoLr5|=q-A6rgAPAx`=Esm_!@FvVoTX2xe?HKjJ>VeFwa{y6XNchTVq`uL%FcqaJ zP~(`RHP&r|m*I2A=^Fz1#ql4uuZRYs@=-sX4@yJcLaiokKkiii(PQ^F-~rx5<4sHa zNX*5DGD`g|6<$WS6$++!mZS8fvNwvFJpfk1H^8AjJRhi*XvNjdT;&+f!d?afgZ}8o zYHUl#?OJC%!)SRdh{n-LW9mWn7pPf1Y;WRZEGOfQB-%*A$DeRSvHw0=LtLVsB(-_d z$mG{@F;RoqA0i2vST>8r< zvJ&(NGniQDfvl3KJlNS9J7-U1tKSLbs&SpLJFos z6vC!ec6(QS#H3WikB0cw<7iDn5V@?|X!B6wpIUuMFD6}W!97hK%^zZtWV6ui#mx8f zQs=UD>kOS5+H(VMI_I*SPu7@()=BIyJ zGga=-VwyPkTu29wL&+4e$|ZQbGvZ3+B?3XneBZ)B#&9tY4iVv$cDd1F=a4C;pmcc| z=|E;XH3(E|d1t57gE@ySDJaScd)2V;U`q}VwXodpbMuviU>b%A65+a5-T!t;zWjoXm2r*(N|(( zuvTehjow?(n z5y1Z@+^2pm{}FoHH9=4B_EAhJgH{&%)pd!($I^x8q}e(*Mzb!BLSkEqLJ{M-VA*@kQWsA@8jWx)5c^;XCfcuJUfU) z6JD7whHhpeBW!YwAE`1u`EYyl37zU0i>LUUFl^qd7=cfKT@;r!R{cy?U@S|T;j$}o z5-1^c$@O(LD>xPd6;5w!=OmVSp}Q-Q@dH36LZ= zS(@agJI*>;qDve;kEcmED;oyj!Rl)hNBtqFnfT(#!-GjcEZ8+pVf7P1&Z(0_!FgLl z(Jq^7NDxpqfme;!1O7FUzbcr- zZk*_gbQ3x`&Oj>Fj9{XF%F==tRs{y)RaQ0Pt2!_M>NLvI5hrcH zltLrp!F5)MWLB#h+}*4<^sT*@8w{TpjCdJ4Z4H=r(se5{@fBagt%K08JPmKZsprr0 zG3?5OlVzIHUT1IQadU(Y33;%?l$oNYXpB^GYv{ zd%g#)7azhB7R#S9Ply4X;mfy91r&|fh^;4xB2>7mxT(KK+vVByuu%ld0M0m9fIbDs zHbyhOZ3{nLwX22{-qp~_pgM9b1Ra#cBCm^AEGHcnLCVTGEx%}ZA&zkt&8liMD#Av4|D(&|~?=pG0F2SU1@ z%uQ#q61+eyQ83)UfPDT-PCpV>Cz4@NShNIiojaW4XFsu+|z-$ z8fd=VwCO1ZrI7YYmTgeZVaU%s1Lu5L+`76OBNVh8m7)r1h>iEO>5&$UV$$az>1`k- zzPnyV#`rxnR#e@1Oqkm~rP6ioA+sRGkS=3vvbQ{h*d{_T#XQC?{G8Z#@4Z<{2s44= zAC9x$TKxW!J`xpE>8bMzrQ!3`c)fMAe&U?L+y!R%{t|yAFIlRQDY)v&Ypa2_P5jw- zF^D~zEB_E~rWLSM!w0F-ym*CK^|O7-l2jkF*6FWolZGttU(- zb;*wnyj^pwAUnT)#_Em<>w}&3@9gXO8sKSHT3dF5OLXfWXyHpa$R+c)uN1ntpdpQH zQOjYlNlVe(ch=fERhu0jN`y*0OlUa-w!vry2Q~#ErS06%(8)&)qXb%9N1a2Eyw1BxD-BqWlC-2SmdrR}YSniGxdwHiKA)C3% zq+gyqr;xtZ-n+D=phXMpY4!kS&_A((t zm#$d&A>_hsvxSR|x5b%df||>W&oU6hS5Utk6U%>18A8rii^p$elMLqh+8b*{_tSf` zigl>3b#TG78FHezmT}xAZ_aUb2ZkxF>3*R<==6>a!a5a3sI5gIyEN>r6D<4@GHodv z-wj!!KFIvWWAdYbZ>vt##J=L#TbRmgWo1^n3bmPHABrDh?xmGGl|Uvc^q8{maYD=w zKBac9OkJuM)UhEv&tz4!2~m8uueUN(8vX$`a=DGgb#6U>Wa42gOr+(fs@~+#57FJI z+s&-@8AA8GPA=Y>I0{Y`6^gz18742!WaFu5G7EFbA6|Jj zU#+??zyI-RCSC)6k$P2p+yPa223RMy;i78*0^Vau^w9<@n(UItjJsaZ~ z1d%RZD=;ZVglb36>O?1v`0Vz`KD!sy`xW$*i2}7Sn5+Ajkztoa_k^eC^G)en*7W=D zZy$RO{z3sJ?db6yN8q;q0&-LTYgM0YZ3Ue=X2x0b0WZ$-K>{ymr$c5ujA2We`_T+I zI&!-kz`uC**GN(o#wbvk<$k(&1qVJw9mc(6MpFBFIh2)t(|jv~O!Sf{m+w_-n`fV+ zrYrQ>4uQ=s2sl3tQOo{KY`NySC`}M>dxDnR&s$|TSD2xNCRg7@5qL_u{KwXnrZ$Ic znIe>ho3GUSIHIH-$Twt^+W zUnGwIA_IwXd2rwAYozouly<6F;w$<}2V$=^9xVI4om^SW+gN8EC{oyy!4iwJuE#{9 zV;f;8gL$3DI&+mQ&hF@ulrL}Mk(K3Cz5^?(gGfn zdV@$9G?YoM;V_hSi>=m>mcR*Z4Qlr3&vVE@#WBv(Tu$)Bs&w+W`tXajaI!In6)(lF zlMl%hMHkEL<9qu zNr36*FP>uXrgiX^wTu~saAH7wydx&iPt}HuF#v5uU6r^Q!fI_O1owT7#Kb{Qoa76s zfP$)VdMIcGwD?^?ZopZr6^Y=FEr&784!qe-&Hn=*fOg}sHT1|mR7M&^%9L<5F;Nh& zqt?{2ntUjx(b0Z{4QZm>_cnu2@)$PkbC-cdO^XB~%S#(6HgPw>ZEV?weDzOEzE}ae z^D%4WeoYA58DAQY|1` zq&3ymx6GKWja)g19{Ixu1!wIjJvF`uSSG$Lr!YnYaQT192*ZtQ>aRH6Usk-KWQ~tG zO(hDl{4UbIXr7Vs;a^K5#>TDj5(d+>Xue+ws@`+4g;8=0(ee3vo)QIrlJ97j4jQV8G-m2KN)GZhIW4mRm}5)H;1c$MJe zTBFQet|SkXw>_sO%y>}3@F?wpfiqKa|6CE8$8gtsjwDsIU0Vg$_Ka*hJ91gLA&YsH zBTs}9vJKiihJHGkjr4N)+CaSdc77mp*e}*S!cEBAnoz-Fo&_e?nSX}&ooP;}D=n+d zA9+Mw<#@U$PkcRm0M)ovI8swzZJQU92&~R3an0V-gIg6^NzO4zauESf^DAB&Pi44S;*0SG1jZsLe0av5$^`}W(}(vK8URc!|JEwnz+$cB7drd0NSd&bqx6SdCX4sf#HVDs+Rs&16jc8UlXJnx$z0cS z?WnoskKH=WduT2B)gF^?6d{AAqzL2Zk##CYd$y|vS;ML0vAry}AVsUG8Ff0w(ix3k z-Ys2S{I*HZIjBPTbuKzDoI4*7Up0yWdOcF1SNN0dgZQ+k8u0Anbkw4t>JM|`%8A(4 zs6^E!)NlX~5VkAa>=*4{mqy?GnygITKBTRV#bl*Vo82o|{~!=NP%KOV@x^*t(qm(Xjtp z4aNCF7zxs5SLnK^SGc$a$l7J~Gcx^9%Jn0$Q5P)o`eNpus7^|1h$)f+2PBg3YMtfS zYQgY<3)d2p?6hH2B|&o>%^(%)#7u$Hl_jQDKa6C1T(D&|w1>a36W{uGWGlllb4VS;2XbkemJjK z@xIpvLO)I`x=sFiHi7SZ_c3ZSLE^i)%!U8;#>kj#D7jX@2$@PE7-6q5yX>n756XHD zhn3&8a;8k#B4EIX1rAO40DnF@{;jfpI;t-UJXZZcstioC@=TuXrWKd09pzf|dWof`}Sl)fu#_<;X>c zyskO+LyxXt6RnbKJlSAN)r~?I|I314{l7wFEEOpnaX39yD8 ztbOGHia5bQ^SPY0cJvmHW>MgTP4vWz4~v;~@uB0;jc{YBGB<&`~ zwA;CDNVx+ftm!fr-zUE0pZBV>@6alqSET0>iMdOfI8WRPK`AuGEX+^ymZcu{(=ySy z&u>~3Hu)DLXE`^;&JZ|jr(}m9uykzT?YDmon9EbNYXKQl@J$;M@h~Mhp%r-5aTkKh zvn_zCTAO&GRD)j$;qeHlKWT28R(ySN%gIST*ur(`lK_ZTBfe*}+b$`u(1k zjj6)Z6ldTSv3N54b)7rqnZq5M0r)K*1Vyau3j|zlM zTx^>IL11UM>FK7eVh(-MZ%Yi7y^5`6EZ(HZxj(;0alNK$bS9!yXHH&NyekzlD8hon(7R8Wzsz>Tlvb_R z)T}j<_4I=2ndgAT5hzQ?hYB37WT9%ofgEo-o&qzQ zv0K|d#PKdq7Ek;Pm_RymL>=k`qhcJuUj=8l%AB&Fe_252e#$<&gO+(ck&BKU z60UZiIaQm3AXB@IZY=W(qE||-w=vV;CD^V_7dM+@Dqf(nFSQX@FT&c}5+dBSh3skP zx6`YnLNB=Wn=NCL7Wb_VGE-k%$KwBE0M}Me#87~5lm1uh|4TEEk1P9~qxi??z8>WI zDRY1T`0oJV<)YDa$xXl(hrc zQ0JCcO#j|MVMwJu)l6P^Eq&rKNj*LYp=1V zO#qOslk2-X%r@Uf=es3)&aVhZRXov+` z!m73QzE0%PI2CYj*V z8Q*JHjzUmV%7Rnt)fV>xJnM1mWs@Y3I*>``6Z@Ub5142%LAtOtK|E6WKP z=9yj{xf!y8&{Os?&S2g#$~srY1#5lFvryl+Y!MXVfYW>QNkxLd^bO;fmhnhNn-|Vu zRi$S~T)S2=&u@S1xZ^j!jw}EgF1+GqIuYQqVey!qM;Oiq+`sy zGxW5|LwA{r>iKLr?n0W86$C|wJjZYEiinUE;6E3CpCC$AQi%>3BL6HBEZvkXE%r4> zLQ_yL<)#B+XvTmQ+sFyV$3b1Aj@TZk%CU0sS89^V(>8H;hfsX6JoDc5h;H87&LyEY z!PbZJu8*>ZY=mjmtSZb=Kw}aaz;~hpT3gTmK{2;FMjx z0q(#Gvc|^1AE?Rf3QITdP}S8qd?A^;NI` zKis3aasA%{oZa=OyH~N-g17xoTYG+|d-wm#_sGBP)9ifkgMR2bJ?nfttav_pd+eT~ zc@FkJr}>lP=h8%y>xrG_v7agXlN3op8xt`_(`}p6gqE7$HTCbz)3xjgAL-xE?b3wK zY>D+8H;vYKRMNC_^wfqwekEw^$tcblOT9{?);|u8foFvn*qEK*OPbG+L7!(ymnys&FWBOmELOs8 zBYF!-^-5ykNOwU_<{n1v8)m~u*(RF|_`GBFSh#yDQm^ye?n7nddY9YI;HFkY!&r`9YY~Y9%ciSIVr)Fam7dfQD2=sAd z>C6Traw_Xlq<$2v$NK43f^g;w2;Q<3_WK{Z$5o^|}KYY9V_G0)(y#DsGKJ9;F z`l9P|-%qpK{qpT?x#r3H?H2awisf}6cjNALZT%_ER;^oj`N}HTF?Io_x+ zP!79-3KJ|uL>wtqXA*6qAvR(G69EZZV)wYBy_WhQ9X{~E*6T)@w5gWm7!X2mkN+n2 z*p1CCg{89?YTjfsG-=#S?GXEw{IW(7>y^(H4?8qS!;Gzu3BZ^aLnlu=kN<17pl>TI z+|m4Fl=Yf1ZYa;sAi(cNb`;HJZr?pp~rKL*b3^pcQJ2i1BNpjSJz z=DKoyIk$C>J7Y|5wEG2PDxQ_#^Hs5wbs9G#Se)>2NsFFqR>KjfIY|T) z;_p@V{!08gXUW;Kc9O+pgHi*_!(*dpF@g5RtXD)8_mW)*0JKl8W<{6@+;Q48y7c zk*M6)PofQ?A<|eJ677u-d+n2Y5kc3IYD11ne#moCE#2~7kb2%gz)Y%-_zC`C%S7f~ zE&q_vS&?luV2zvk+@5U?@pn#ujnWOZwf>gpU+)paW=Ghhrr=>C;6Z5~HM|rh3vO-8 zgwU>?lK(||dpmxzW*QP<=%0#{wxo}WFCBW&z`fp z`*U9!{BMWW-+q3&4!_Uxzxvj7aQ1Td_ToQX^Lkiw`JVw5(SMWsIduKnySk>PwW}-V z?PbaS0?u?k#npKIc>XoP!Mz1B^U18OLbOK-RJkThvQq3;A+R}^Auo9ECe?}5bAVQCazBTp|SLf>Ug%$llRi$Xzq(pVIt5HG&5 zBwfy;UaIdGrbv3IN@YN(+GfJEzcj6-m|R{%t>~>DFc_V8?+Tl<;P#B(N%dIM&>TU@ z@pfjUrOJdzxjqznkt`FZs;q_@RuB>#2(PKoW708fjgiQC@)H&pPIy75E{% zmLr%pCe3__LC83Lb!T=#FOU-yPPu9*Xs^Wa>ZTl*Bb1xR)}e$ZjuTLRJ0K_#Mb4(| zVv(pny3_|1DDq+xA;@nxtyfgYr`PRjV6sJX`nOEh($fiU#e8nl#D_#ZR}Z=JsE99Q zHFI{*_E=DGUyy@xHh-Xcp?c~%X-HEJv`F#U)dd(qt`UG=42!D=e}L_ctUH=)W;Qjt z?UB2fPERhUHui;Tsk;(0%ZR)&-M8t!$Gc@>b(Gvq z!_aZ!pR6VmpQ(RR6?%>0(kGNR&*=F=`)a_QA{2DYyd0jXcdpYRZbH+>mA{1L;8=3# zo>aN%uQ9T6!Oh<~Ho>b#At_=n+}o8b4x~_@?3{Ysa4ETNd64xQo8>@5V^Z{No3o{m zju6$r)=Cq#v=`LkgOAJ9yl&;uSkofMHvB(9QHhUxe}um>%zM|5EDKNDHq~`(s^U#H z%G()DlYQz?AT-(;_(4#bZF9F4df$Ho$U0P%16I1;N8&Gj4; zJ2bVL6R-RGzWkyXE)l-=-7tFk;Td2z!P7wT^kL}c*_dLA^af-}+I}~W#Qp9YrUNO? zJdxq!wae7qep`KP3h%q7MUiskp$Pk?7(nh9M2dp~XMg!zJM#I`<;c3Pq8?5}_WrFl zVq*Pme#i}a6vIdN`|iGP&8tw5-^n<5{N7{QKHFcT`GZJz^KyH`3-r6+`jmJFsOMnZ z^p(#NQ~W#-XXXA0$7chv7{yXe@8j!<#FuUp~kA;gCK=6?G``UBR}{raL|y@&(U8 zn82u>sD-z7pNAtEYSmg0{Ka*)%4b}@rqd8DwSt9XW#%fZNehn(XTeyuKwZmh%>Hc0 zbHVT<>h6Zo)CrmK?}8H55?r|7F!|d^x5jMX<5#4lniZ$7*=JO!mjUTb(sf&GzL>ak zYKB2Hiy4u04!$4mp+63U;j;7w(%|cj@pyOebE#Na8P%T#3q3E%gtrB)Y`iI3i)u=w zDnaSLP;*8t(*BW>C;WLYMe|Q2=kvRVdjVUK8=g#>{P~VV<1uX5w*LNc7ZsMEg`w zC(FWji0jq$FSNBWC}Ey}jR{$b2DAQvTqU@cW!rU7lma;voj$CZ7Zu)$7Z|fAIS0zY2_BF`4>sVqoDRJc$y%0e% zKr={^0u^=x779^)rywoIe7fU`-9skMcVlpLp+bf;ef~XE+Den|Y#gI?DaA%yk=iFp zBBY9lV8$&q+(HLopo!Px=H`P9-Q)rf4tKEw+UpOGu@E`1wF5RaH;Z+zF)U-UIQB2( zs3Kgw=V>Uof`8idxaV$jPB4ucf53Hl;a`e*a5#=B^yeqpb)BhK-0l_V^!$}zCR*m! z?;&5KcWKgOyFQN%xtkA6@KZcpk16w>lj8l4gKAg3ygVq&)t=Cpc~4*Ol&8mc^BfRv zp|DC(pBMP$mvAGG^U-gjK0Ugo59IEb9aZxn@uxxVUiS_pY}3cF_vaH8`%TVoo4zKV z=R_uNDW;o;!+w}^)3Z-3SFN-iuZO146y2^Mk>`FjjFKZ=j{+?5mxfQu-QrgqLnK}2 ze5S&}S;AkZJdHg)x{5(8M=81{P>}dr^Mg|Nc8oRjYM$HWWocuF`$hHid8}mjm#-Pl zeZF5PhT!Y%-YaoU=QGnia5EE*a_@u5PDM@URR0ck_qlTSKuy=RUylC{(d(J6$GPE7_ua3Dnnth$3ZJ5UIb(;B^<|O z2j+TPdU^8Md`~kW%_&^_QR#_ps}OpLz2@g%kJlg=9i4=u6n0CzrDG%nuqWj z|5%YbirfyDwE6B!j+(c7)1B9sr;ghtd)QjL+)d5grJ7B(=K(d*Tm5OHUe6x2mlXf= zraKtw-70qQy!M|OI$yw>_BqB@p~Zf**bf5m7rIz zSz1gICNH%rH+d&ix#chk7)=1vzgx7qz)$&uOe<{J2gZ3PnQ*+z{C*?zDj=QNva=Tu z=oNr{Gc>pp@LrF`sHgKuVcDW9a{Cv@&=~s+$!Qha`^0$nN{z%w@%HU3BbU??Jq3oE z=wr;`c+IB!#u$Yze5?$uDnf?IWu&~{i&U{y#?_*>pe_#<&{XNHv5T7~{3pc?8M*%l z4ngt0o#$Mpah>O_$8`|ECC*E35r`4N23lUR0lq}Uc7Vtha!b)7); zPZAl%u>{vG3-XXiy0-AuB&&C4q^GAv6!~2%@0Jv_q4~llgMfsQI%N_7-8HUO^9bfZ z2HJYw0usYxCDxp{=d3Nmh+(mD#iD~ByqH!lAUZ5r(_}Cy*2RK>4GsrWO{rc00~J`B zuqH!uM>-+zdx-nf0ghW5NMr#@#40?{3x31Di&uF%Knjj$T>QZC>4DnALYfClR7rfn z((a6tcuyu#GJVkKQuk&8CuwnwskAxeQWaNc_%;&`>%P9@=VV$0(S~e0;|C$9brIOw z1dtJ#U*0XJoAKO>FLM9&*KwRhD>Os7==*2It-Ui&r{$u;xoMnOMQHXQ;B8Z$x_ilk z^A*yB<<33eRf@m4IK?a;X>dASuq>Tsji;V_mdo=czCGl0>a@16=hJdxxx+NZJ@<6u zjR%c8uDsEd_ka5bS-<>=@Ibc4OYi>S-Y_`FUJ)(8A=KmU_-zv6d1`@MX=gUaVv^~9-no`2>pmv^6H^bcC? zSK7AM_{?WNi^{_HJ^%ma!KdOp{lNQwfRBIvdF1ua0r1_w{YT*a-w(j2ug-k+3t!`f zrSZ={|6TmbXTHEc{K_lbsa~2zx@yM%<1jd0$10c=jE5b z%F>_ZLm&EMJpAI<_{3L!nRPw!Prdk^{IL)HQ*Zk-&%gF6=YRMb%Xd6Q|J7gM>Wi=Q z;otF3^Wy*GBXL}x{xqNZ)Tj8s2R^{}ec$)7t}8$B6F9^b4-EPnC zH+TET>HL-&?X7I@8E|^v``$-u?J;)gi(mZWV=NTF>#x7g&;IPs@^e4;bNs14^``(P zW!-z{$AA3C`2&C84?OmJ7Z(>?TwFZ%_sg=p=NGCqMJD5viEH_P1Tq~jWM46))_6m{ z#Dl(a5}|uXhRpbK%h+krmP|nO5c*`z?Q$LS?K&-0*{?8 zR(J^8gF8TaoJjef>{7k(I7I<{X(3%OakkcC5Gg{}Fo18WjOGjxuKQCAgq{O%jfShR ztk)r-^B%>RD5EJ=r$x*_N#I~{%@By_wlB+>2mOj|yThgfQKK1bZUN3DK_r9b71Uw4 zIy%n4!nrNXXa_$Oy156MDN&MMhGoF{RE2T?7ImA0Ym0H({0e2zTsa}QI&C$?)&!5r zdU}e>t1lvchV(d$CIQ4+B&mhUOKBNiU}~AdCak*BZ9!ern`GG;Kd^-^Q>MncC6gKc zHIpR(Mi$wZwtKz+?wIl*35bS+D+`Tl8s`Eu3Tvh$R`gn=wJU>xX`4fjJy|J1<2uRU zIN!&yI2N%4p}SPiw)8lOgv=!wr?AFnfQJaSM0_MaOY3?AbC6adi( zcicPXk!bdEe}Ui77ui_Y6Dfmn3j3AeX@Iwss!4jG97%5>IdFPpx<)iMra#N#|98n_ zGXsrKi$*3QiXaBdmf;Y#QXvo!!0FN+vR1pn8zSkB8*wGKn!PjjMvmvt#+8a0W7^B> z6VV@JeD~4gluv>HMhGIEChta34->L3M!<(lF6J z;kk*Vyp;scim0G#?AyhiyV&a)NN_qK4+Y%vU33v~-azXYIs8^wmIdug%1fQo=`;fp z+>PGaYP&@4mZw7uANCu&q~!oVl>UwJvlKF2rJR zwFsxv1t*PWjI@Q*a*BIagwtuEKl37d=@anu`&k~G!{=m%^N^;Ed-p!V_4TJ|E%tig z=(2F9-Qz4mlXz#}WSm+I-qlW9PBT2>w4CV6Y5JVn#hsaAc-KH%G)FEjo~CIe$_lXb z7RN6UL~&Y9@2D0qyUhKHdg7u-a-oQD+22`xVRue!+R!1~krUUVj7yoHrK+eZz4sfR z|BpjG^R2wyp5Jfo_K(B)eLLU(p1B53rxQQ;gFpBfMfVdw@e};M-}n0-`}t>{d4^y5 zrC;LbfBxs^|NcAw&cDO=ec$)-^FROd{Ll~m&_AkOf7dp7;RP%`PGW5)b5$&oN)}pK zWUqS78|`zLz#V&@EsEccs$v(`ny2N71 zI8i2AXg!Pl2NzLrwCvau@ys>jNe>aSCl@Y8%sCm_Sd(c{>B&F{%e7#-alUw(SNkbb z?KFKs#=Y}{NE^%I-CASxWp?t#_Ut87i6pctDB3{!hKX_i`jVlJG>@UYlIHy?@_ex5 zut;acSmU_dBk9X4?Jqnpd-9i|T18>2uZ{eo^G)$>Z>P-rqRG2E5K!fnw|hD%8PdK{U_3O;Bih&RsanRl^w=#9f1 zmXXd0&5~4u4Jx0&-Qly)1?K{%S#mi!AL~TtT27qFm~atR0ytSq-&4xWAlMVlb8AhJ zR$vo`hE#7%6TR)AS&Xe1&je0zh_=tf#%96t&4jp9&XXC!x-Q_tsoV4f-OawzCJz}E zqn+RGG_KZ5zWDHIUT)8`%T@P#z*RGF!S;0;{8IwyU`2%o&IT=ord=hC84vU>4_$>M2*(AfDpj!nX4DZoqjKF9~|zMnh&E+QSzc}Si^SGC$8 zTU|TPrbqgJ+*wYS)Kf}({9c7a98a1^KcuHA7kBRFPZ+A<6$3CIG|@~1^%xf2WL_$5 zmuz!zY%ruqcz=#t*G@@YuOB`DyXKkgnmgw!P6{U(tp9)Z{w&zGEIZG`zA@&UYpuQa z*{8XE=FQ5cT2zZF^nf4|ASIHv8d47w!VUFcIb@mN>Vk?3ID3EBY3P7Ry%0BaU=bmOaYpprw@WY&IpK~*_P=%~2B*-`eP2T3* zz1LoA?Y+l8{(t=cw3?+JUthyy4l%iNdgtMNKMFtgXW{n8FYL%IlVY(W@4CA{`P?!y z#+)#9v^7ggcqem+Nz$xO<~Y68RqwJL`DIrphj~{rNxt=lL^#=Fjj$KlDTV_>ccMKl`&k z%S$i4#Gn1Me-y+^ao@t}8cgbhe#Bd0oDxc+0ydi_ zy=4|(|93ahy^!h&!H+nniD226D#4&ec7f=-;<%Paj5$T6DP?a*GiE|CUjZx(m2qlak$RcL0-UUD z_-tLKs=b&NWDMB_Bu`97cC{fF0Ts?TXD#Qbe7FLa^7@07sePm{8%mKv_S&$`QUO7+ z&o-61+h#R`NH4&|#5k$ej=TV;vg?y~0kUG5DVRA^tiHA00CkOK*I*VufwDi9E$tc} z=^|=N;rU2Z!hsO?wqhggEE`M0qbHmj=yo}(j0;fw^ zGbWiK+r?PV1lyM8)O-zE-5KcE4qyqn5cf5Ai>5CCvR7mVt;;w|%&IJU$dTQat0-Q4 zamL%Z1lA}91=N?_MGW)jr^|NamtFN-_rzdh+Ebhc1Mk{Z@2z&^a>2mAYgfH$N1nHl zCY8tU_2PPcJ9gw(byZjOy{-2YIQ`7e{0t8tKIAX`rN6}MufNVGKJf{D?&p4v=bn2G zfY)Dt{aa=_{fk`Dz-o?+`QAol%K22l4+4S%4A_{g%z0w#*4TinXu?1T0xc%BkF`p z;A+Z%B__#IW6-3+oki!$g1&Xtm9B)mhMbXhi>R`ahOwTGERI>+64HpH8d0b)dS9H} z^n!7kGImU$$y0`p;F^&vi6J`1R?pA{SXB#%B^Xk( zNQ}}{IZGrhdqO@3a!r;=C|M2XsNgx4y|G+GV!cii*WK(MOffgv30v8D^3?m%z$<;~ zK^ijW_zAX(;p-$f0+Na>uQA6)8iolPNwLGvBD>u-sVr4_`bmOS|K1n#63ws(01;2R#5i^Hz1{0mRirX2DR1$5 z!K6TdOBqPs&508mBo~9ZY!{*HQ)y++`t6#Ww|K9N76{(s1SCbEMP0zfiE*kqPIgGSJF^_E|x5tM%Rqgou~R}YNdG=i+J%g+3N0sBS}QF;k1Af z%cUu_*_K(_qO#8>lxchxWf9l-obW`S?`*1WSLH(BEahI*_`Rwjq*!oe7RC)KOKLbL!| zEs~<*E^X7g({2xp9k^GVHK@VLZ;6r$Q$-;GTy0JtAq<-7qp*@(0Jc?2dMIF1%Uf-_ zmIi1ulzS!$F_r;Bqs2wgi6;m|*`ifqXlB${ECfdqR|gtpwt#Aeg5`vhNvdb4 z#fmY?d)-~yEAy5ySAm3pPgMX`8DSM8PynsViNf_L8=E0haI*@M%imiCPKl;|t|Yub zpqxi_<qU-T7GpHoou`~2kM*u}bvJZ!j&%YKHuJ~jy-|B-1FRW}v*=b}5S%Oa^Rw&_ z52-@ha)1sMM~+3#hlavvim~2%jF(@A`7eVzD~wMpZj!iuH*zry8RPDEg*@(g&b`XW zAx$^iu@f#-1OEz~F3u*1`b&(H(seWHCjqL8ld`j$awOPT_CCuS6x;>V;rwhT)pP35 z+UV!>cHrbB5VJ83=ZF|VU19j8Ex*q_i3QGG%5hTvL;!B{mf+fnIa2AFfD?fC`=~m+ z3}h)gO0%%2$MJUHbm2a#Pclw?bE#f)q0uZRJKEJxDl1^~QV8(7Wt=8T)U3!3{j^ib zyAQyX=Hggd-yn@+yDeEx>-Czmvol158#ive%VWN(tGcT1w627*?_sU_5j55&yjXMB z2$W(oT>O|>)sS2@fmFIbPqC$LVyu!F=q#2z7V$WZjBZ5bI;J=1S>UV8EK*#|*iF#| zvsAc>3k3`YbXLF*fcFE=DRB%t-~MpyHx#1nEtEi)UomSs%@Y;iSQ8+P4^z^X=4rhzl zrH^?rp^;e5e+|*r;+=ul!01ZQu9^~uI#Ex$Te~VupOLFs1yX?11WEmbo-h4uxt|r0 z;`-?*;kkntZ7%n?Ilp7AOpKn39Vd&01S+Vt?9xov!BptG$DCh#jsDt;;H#+yU`^Ro z%Ds|$!K=sXfJ10=O_h>KS``>YNhy{9Txpn+q_*=D&iO5HXJ8HU_)%o6E^MyfeP)ho zXcnlhq>6FiUgSf~i##`bnYQhAgBGo>aZ~Qk+oXDV+D%esizgW;)#9jHhB#}gKoYeE z*#RdbggI#%?5HAI!P=x{y;M#EHbP8mM5OFaVI&pke37U%3$H`EDO&po_e0&_pv3#IApNi(*%5<`~dD(@c=IE4k*7|&z zvOiL$?oNg4qwv%kp4m(wt4Q^Nccig2K+`T(YR%T5_aAdM3FvafzTZJu-Bt~$ClF1au zHcf@m9LP+L?d7&B*-N>~ZAv3A?CF*p zZp95o;_h(@FsMmU;EsWMKD6jKr?O>mp0 zpQ}4gYDKDtFz6-5slH$8owx(5069X=T9!yKoR+X%08wF6vwO@9Xmcs&tSLd+X)B~& z@y^q@9s_3PN|0;4ra>C+qvRAh9Je41>qqayoh@j_JIwM&q5lA~{t1HKLQ-4qU0GL2 zADlOC*Q^VmdmB1EK@1N4W16PB_^kHjbJ@}))w=|4H4tkUqdG@7U(|D03|0z5IT;+R z3HmGtJkMTUV3(K<@8`rFBQ6(=Q+@}=$u(FsQd;90#c5N<4ZcIf(Ny5%oJZ@umni$O z)X%QQJ?Tm{?P8&QJ)Zsg-#t`4L5A`kagNSk>^Qx(E}KKVopHJZob<`(pX7Q&Hk@`$ z!S9X>#;M4v-z7VA=~&DnPA-nMd6(u5qO#j_YFxl|#VBMLh8=Lab?er`g59`tD5^yqiX~`L~DbAFn##tyP0b+tw!vI&4dzv^FX_OgmyTLMeaiE5cRf+=) zHmiFN6gzTPY?(`CAeUxUz&XKZ<$7OcnOcw0`2imsX=sYXZY)h&aO>LGR~-`+7cd}L zL`4a?G-S~^avG7G>xx!&S8Ebz0=H#8_H|NSSPQb!44yWYJ%`abM5jHCDuK#|R^MS0 zAq;zkaROX3l--dbus`gPa>2$yGEPN`hZ?5r8vMePOzfjjT`$NgSOsxy+4$#?KSSFssu3^BBoWw1OP&lc3cM=+BgP;J??;?Pax8<2oCPyQoT1tfREV;n465bQ%}NzsXIK(#ozz z9IHIr!HifRSL=?GStQ%;h*1+7B3T5{fEtA*!4b5@G+|O4CoMbTIuvt=-2}aa@aA-J zWRn>mXNBYdB}Z{ z)&{?O-{tCZH{qJMhSE=rle!5wT}btuIznZf=Is(!cPrlsI8EnFaPMFaajAuQ3vheV zAY#6|pHwb(oZjtz6YvB}Xf`oUlT`2BKdx5bBqGfA3urz*KE9IaUDZ|n0jVqC^d8pZ z$6IV?Zs2w{$mJ{2<4^{lIClkTsDV#w`h12;$!O`~fJ&irWEjA-$Sfq2hi=z+4NMt1 z#r7FDvJ2XkRGabg_ukv?*M*HLazgKiON*aO zWTChi8`4z(>9@48--Y$ID1K~_EHq;YHcjd%##$3_s*`UUD8LE)Fe_#e7}~^gESov= z*j3<^u`pJRl2j;CSUr>CsOLnOO~8rFh-V~J6FOll0d`-ur3)}UyLD~ z`Ldg1nR$Ltj@y-~?bITl2d!*OE_-b1cFlp1ne3gjl=-QC;+cjI% z9hix6Dvw^pbXsJDMZP2CP;@WOzvvCoy8UDU=296dZx6#UvdR5 zUdr_XBWFLIF#tjqtUA_t6;#IZbLI#;*_EJDB%E5AQ9l+=CQ6Z4x+>wzu1e%mbsV(F ziK`h@sqB6=B$5c~+A=6fAb3KfWT{eMHDYaq)iPc$T=jgmodgV^^|Avptt+`}R`1iJ znt!Dx#F6U4R~uYEwV8mwSp3fl>SjCkB*pqc;mTR|>S${7pTd2_d$8hQII}kj(_xL$=- z=m4WVI7LG-?l_M7<^1TQ9r*T50Zx_@Ip?>SLtHRU&NBZqEsRq+@AeLilh=kk7Pij?$6O0L6v93tjxKM>2u_t*z1XLT$~cwZH{VjK zH!)62R6UIhm?-mhe`h42@30$m!8pBxtKI}q^iq^UtqaB}-n9y)5#^^ zRt6-plPxyi0dSfOBE$*vWdTl;N!FE2@2alqy{{|a^d8pf`L?hufJ?<3qO=>3vnzJl zF4Fr*vq|{Ta5l0@kL$k^W^t&?_`o)!xmf<1j?hnLyP1)MTHT|WfYa2fNXAIjRnKUf z%OCoNXaPaaN1O}9p)Bk(Dj0Y-CEj21(=r1RtxXWDxeJ1K5<-jrY^aMer1$gHIUD-x-!y31lJJ$$tzr?7S)_yk)@fTgR9P*P=PZ?JJ+ zhPtoe>lg0IE9MlDL?DuOdoGY0b}V6*k+2IVE;75xEzE#qp*Ye>B2|fAuE49Q!O2Ms zbC-5W5MtdUfjXJ34rZpYG%k38%~3LgY$&bPg%l1dpw*$?Ynj2Vc6mCcMXHvy#=ll; zU?_hkQmm$vI8rEXVLsRWEx%=Ib%S5gAv}{Gut#CDJTTAa95gEqW4R}@fl9S*5UG1l znb@og9E=4JWKmM`7!LJv zTF+H^-g18xsa{aQ?HDIVa2GpH#Y7_G$kiO83{#?&Q(<1uo#RoR^k3he zplD&7RPnxqmzLR0Aat2jgL-{P^r1BOP3$iMZ_Q{#cFnAq(M${NVr5|9rVJ=!DbxOy z(5Et7a8jgtG#8ATI*&{?;uxN`d^Q-xB{5HAq|sWB%ZVgPY#ca;o- z!W<%jl}1E>nZJ-gi6qoTG?aZC=Q}JH*ExxF7e~g%Kr|C= zL{nv5)M(9@P+76kcu}O|z6eC(Pr#;>>WYpxT3H9IoDzDwA)bFsLtJqPD~eI4$5N zsgNzUE1Vx7*!wIbI53H985q&{N1Xmy8{noh%iw zNI(fV)EvV|Wl0NT-7dloI7tOg)H|xv1xArjl7;Mi{cJIsag8FZq)6CWy@70RFwkON zakCL^#uBbwO$se3ZP+haNIubKUznx({JlQ};M(S_IFtIYyNB@?Zg?t+b6tJuEg^YQ zvno58UO4rEa8SZt{q`w(n{ix?B(go&WhjNFsrNgK!|){Iq@H*gI7wxtode4|kRcOr zswYt^5T43wcgY+=kl&4Qa&3|7k@2ChT#i8U3nT8p z?BELWq&Wn|5mY6!==OK#;+^cscOZRY+NQ@BE%Hrxn@kU$+;Q@5c45n}Tm;F!Yezlm zFy%i(WP@x8&48zAdWDVN4sK)kT^M{Ip*T(8Ab_ET}VvWbPt4i_r(k(9;ImMLv4 zrV=@fWP_AeJJ!Pi;>ym1N9p=QOr=b!$*iSJ05gv4t2M7pj8i$AVuGXWPxvH^5>VB` zngAAb7d15fvtARUWJXs)Vns5ZNRkOS8Dqolnq>yMWN6(Ja4GEMe&w2Y+G@IClzW2; zoEjRmGEQ0j&Y93~j4Jp=gKHgwo9*PIStD3r*uO@e-GI>HY+G$Az_q%&{^t&!iH8Vq ztQ&H8yfZT}fuxR98>NnmCa&037eJC#*tk&7ZDv^mgQ?)N(H`fv7_h;i0t+^n8S^Gp z;FAzb#5D0@1+EyG95&T(p=RQ!V#x!Fdcm2Yx~h`XGHg((j*6At5@5g=a8%tAg|fh3 zcDjmGE{KsT>uFgrFNJ9fT0%=HtY+Ibh!)vvm*>oV!``SIY%?ASr8p5z z1_eolell7x;pM|4FyZ$2pg2q-yZ5gTZ8__??3Q>R>LgxRw{t`@uDbHg4-QHuk-^<` zL^5^^Tif`Zlbu(oj(Z>sblGUEfW(+RDu$N^6PWMKFBm5cgerKz3%2NPC00}&SbLV3Pnk1;IK`G7P7<{EOm7(BGiwF+<|!De;XVPx@`U(jL9*5?&C z`4WEs5Lyx!z-h{0lGNg(C%3EOc<6+7c8X}mq9df|Nv5pRyaWon^4tLGnw<+>90s1; zaSFsZN%cHW?D6D;R*)c*C*{N{Imd;Aq7Zy{DaYwDO%M#sVmO+cGiR$uH5+ z5zNTe;hds5aVFvdlec`pt}#is3S9th6u7_mc2rqIY=L;zS6h2nmS;t<9Nnh#;)3uM(s! zFqFnE8(3jW#ErWz$J%A>0&w?cfvpsfp%Q8Qi0>W)!uny^m+?{qWXA?IqjTpK1?*ZO zRE%cQ^hd4JP($n#m2sEJQyRg{8&0tCP3L^>t*HM?SQD zz&tk`vM9laS#ZrzI^5AQOTH|{Ctp~-wis>r?b$BZO3e^0Op3>GJ$|UL0pyxHQlwD{ zhj_(J%k8j}>XqqgVQ88Z$YL~Vgo$(sl^Li;0Sc@&(`#nb!hS%)OCo8zd;Hi;k6wK8 z_Ex7T<@JTw?cU5WDNaHO2$qsSMJ`!Dh!Ij-BB!eCQ8nY51PU8zIo~%P+=>h#K(&rW zB9`XF*&*k5KFl&N33*%di6FFdCdzTtj;G=hhw_qtj0^qF;c)9bqQ%6(fITbM07?^5 z_WuiTI@5XCK`>((da#69z)Wd8_;5yn{ZfI`8q8QU371PQl2{_zz{KN;l?isPj8mg^ zNneyShMiPTt>k}A;@OPg>T57uk!B$b;*oeU^$@H~=Ig7$OlvFcGLZh-$Q-ETOuPY4zHKLv&>xPgkjq1%5>q9mH03e0ouAtnR24rqI>>B*_h7>`It; zw`T4#hh1^_i>n!7c2F>d!Rc5G5Hw6~c>%4`wm1xkD8qQndi`}yPCv^Ke~tFwWi+gx z+}*K+PQSN_ajL+{dvucP3N$*qB-N80aI$v*PQkTBs)y0e54m8HJFHn?5=vH^^I(bV zjmJcJX%i>!hQd5vDpd!v#V}mmZvwEK**q@CFrSYsyQ3Y8_KtSsm!x`^fzA^G<57W1VGApD(_Fu9PX-S7gwGvMS8TNXcb8@Jy)!8l#9O;>eQe=zC_IK79} z_p99$c|O!U6Ck@HcXBw8#Od;3ZH&r1vG)_N}zs}8QCYqMRa|JJXN4XD1Jt%c`(} z;tD(Gbr%LHRt+a=6CboR=D`Z^Xmr@^F^S_XjFaFBJxCNIF)>bwRD&`V7+R&Q&=;m) zc7BXX0mvbBWk1FW>4jo zt=U)wIBm71#Q7S&T{AZ$=LXA4>p+?_pg1#nE$o$%*_#=Xi&2Tsk*@D6<0G^NNWwzd zV_Swjgo$yg<`BLbB80qSB^*;oG6ksC|BmAEn^gCdDu7Np{R-2F(`ncPX3G2t zWL|6bi(InGL{Dd3vA9OTd0Ix)3glegxK)obA!ZDhf?nIMDNQ`acz%j=h3(Gt1d0iY zGhs}{R^Jg2gS|z=I<<_sA+JXQlW~S|`|wTyPF5H>a*>3!HlXS_m;Lg2r7yrFY3yg^ z@w)+S2T&z6`@8q&e0IC+gZfC+8GB4Shk?e=xsm#kpCp2Kw*$)fcDJK;S*quxI{#dwit(m(3ZV1%8t`8JYu!_5`F(B>-E=2`5T1A zeRA_TvJDrkQ%<{JS)>e63Q{#pJr@p{;Qb}3p3_Uf>7C3Wid4_c=;lW|=ERA|+Hww? zyvD0Q&K!70;{tuWFcoUT+wI6r3ghIfK?%U4*IvcOviI3_k!5>`uOKqGw*!vLcI21M z9G-C1dq>8p0w*(6JFK$HBHvBMX#%nN!T^WwY{%(x&1SP=5TbeooUZDs{(#gKaC#4G z82XawXu{nGZbQvoi5wf4rPv#BgIrS}S2|q@za|g){qpb=v;tZQI z=k=T-I4avSzx~<=kZM*SmWvfMeCc{cu{x_hZFPlPAc64%; z1z`|p9<_|%F%eo4-LNXpmqKZBa{;ei_E>PBneKQ^yPbBhGRPd4OO}zi9=|9+F+1h_ z`sawX3BP~%nDgwa8=r9IR`>}DXYi>fV~82YqhXR!l$-fkoH<_gCj@hJ&A4kq2Mu^< zy9T+DwA;}T@vNq-8BxX%h}x7;SQ$CU3g(LuhEtqwFv&!O#*ZcQD;u-c?byAL2WICh zs1mvsh$JMGLB-9((u^cgBn8Y|VZJ1Bwq3AuiM&ump+F~!nlg&VooDhmnQ|N6?L<^K zH{x`XLP9%Uys|+>qN~lp4*Yv**h}ZT<6bOF^K3b@N)K4Y z4T3N;&%6sz@85X#0M{1TT2AmFe64&wn3A+3P@K_BgmnL<-LNLFwq@>`@#X zvv`8vMSVksx#S*UOA0eQ@@1(pS zIBhPu>M2seMb2+Ghw$3&T=ly7wH$`4XKK`enNy*9kLy~a?R zV6nttyZ)8n11=VMQem#ZyDg#vA>Bk+Vis8RYqYP^UcaFkrd$*$lAeA`L!DDQ2dwcq z6Mf6Lh{cXrAY<&zh|L&u&14SYGSEae%Z}uYFqUxC-UoVrUUH@^;L-t&Sz&bqk~fYx zz=bmX?)xHPw917Q1_q?<>FDXU$6y(+kAc#lIy@(`vo&Dm*7UoXzmSL3E(}sCn^k@V zVOdxQ)v}x6-FU$`h4Bf-NhRT)`V#TEFEER5?1EGUL;ciPLk{&W5J9D(Yg<0B2|PC( zm2gW<RaQF4|9pl7&fy<@I&TS8Bhf2#LM^Z8-jc1!9quU}bA_mV~d#*03 zJIIHm6cACIj-19jJ5vj(*;mt5TQ-F$j^dG&;c>YS6f4%xHUXK;iVaCdMiL>NlP4x4 zJ0w@xmt__=Z{aj!WO|G-oYL=)9ADe;^?8w!HmL^(K#V?k~j z0?xbLj*~RqPO7J(xOTx*4RlyB2H<`3j`sX@-goWG+&%jGj;WtYox@~{ znUTkG9?l*;;OxPDL>6>ypmPbMWK%7dOPcU@z%lJOy|X#Q1f1RuDkjEhsEpGz0TY3f z{-pe~?-Ju=cEPH9@3amN4>>$M{H{ITRbACpeP?wAoZiD4b59c^2j@N4Wy`iL z7QCx%OCG8TfsEXHbT&DEGfKd$FAyMmaEj%`4R;e2$3`Qg%@8#ldpjvZ>l0GLAG12X z*1n&CrnZHdt&}ewN9K3_-WO>$#ZK-t%veXm`E9YF-YyUkGPg?;G8Xp3yAAsf-zntN@9SiUn?Rjt@Ie zXHEGsje8u%AH|okKg5y7K^qFtNPUN(CBG&w(4oqpx($2tM3$b=pVPPp#YxZ{UWARi zn9e#GX{1c-1z7qXnSfKikST&=lYb1fsjX(hH@X84dS04|V!xO1;W65tV|ynY-TFGM zEBQ#O;Hq3pFlO;FyDxtYoHP%)W`VsJ_)vV7y*MuudV%>_$&Jb?Fh+DJjg~3+^#+&A z{>|VD$R4+jWAg|j&&CBGS|8EiiaoVtvJN=OEUaPFj2U!ktUK0ClE_VYhAuCN z+rEM$VR@e&+vakhMt7nq6GPY`b`!^HoERs;ycC;Z7s+Pqtq*ZHoH?%F{7|uC*H{9b z`vNMRDgMoCEMyOA4%ZQdAr*wfv>`Tik0>?h7v0Xu>mYv|;vNO?_Q?M2OKyO+V;w}` zXx{7?C$(I%hO8J^c)5s{e(50d^>iP@NWgD?_|=`|H=>OBVtDb=oA-A{9qaZnr~AJN zPB@)q9^C9{bHL*e$wZVS4pU`c`(m5{tcMM!r(faT{tXPppFE}+xAh*%ffTR@?Em9_}mwEJ8K7<%siGx*bw|b{l(q;AZ`ani!75e+M34?AMJpXw-L8&kPxu0 zfsk;k1R2sximSt#(Tyw{hj)=id$K9%e2b<60B;=JAl1FGwh1_Ov{P{O{Q9n87AI)4 ztna-HJl+jDEY5K5V#jILU9WKihBa%l-;lK2e;-&LkZX35hK3M4-b$vHgxM2PJ>M)! z6EDha?=ENw+{KK&_W7C%CbaVzUdsD7((}2;uNNs~$f!1G@TlLg?mrK}V)1@d8*&mX zXVS2wk@o{|-(DnJf}D0t6_W98kLu@vgm8&*0{#5oBvnS*FRtwZaNkL)=PY2!$QZN5 z%^g^Aasiz7(=q(UUx(vwkS#Nuy~r~!|21aKnr^w};TwO0_4>u#V}_s;=r^p8D?a$yfERDxJK+>c+>2%{O>s z_B7%=4x!sPt~VWOhVyHleFT1Qg(SGkH)xMvr8&&FzU6#WIX{K2f0JwL6(_T&SkF5i#|O|x zoZpf;M_ghMVMuHI{L7$s0EpWN+YJlZB2A=~N6g0?EL2ga9M3mwI0m11)r^BYGFs$O z_!@U-EseJ1)bO0m@y!9PUof|Zz1pB_d&b$g!LGkacCX=N!!V0*?TmSP%&Gr*nt92_ zS~ll=F#Q%9J_f-4>2I^R{lmn@Xu^`;Y(K-%;hIsDhrQ$0eupE`y2z@B`N69I9Lov1 zSg_xD4&(uOgonMc!STSBEcf1|83(i*xvBqzk@q3M{PpYTQKWIF*xrCYe?&UWXw00* z$YOhkY!699njz8LYEXo96S_FVdn4?f;&`3qY)cBB)A<_R1m@QtqfO?ivpILuJ`3OS zlX=O*oblZWSx0_iJ!3V0nIn$5);{E1BVX1`(1BBZog4E5+B}lnF(w1IY|W^~2UchN z;{Gj$*zrb4{KoZbSQinu=FQU+bT-nEa5C`G&CA@|dmkpo9UI`<$Pimj+%;^|v42qV z$A0m@`>R~*&KZ2Bncd^iLvt{2#6I5$k8te*@e5LW51#ovd)eWd#QF{_4&I~znsLFs zH(nwf&M*_!@r)ssT^?ypxc9lgj6XUfkvLdJ`;qyqXKhBi=(*kw{LXVrY_sKX z`wjM*S2%ib#+MHMIHNPRcQQ1+WmKD8*R_pHaVLf1l;T?4S}0Pih2mD+-5m-=N+7rf zD8-7qy9N)^;vOJS+?~9+?&tf)$jHB(`LoZx_gZVtV?uAaiL&B<6a4$GTO<_j1in~! zi_!hMX49ej9>GEjtYC2iK`Q8EcAHiiX10VMgz9vCyy)C6Hh{X;DuKzO`Z=UmI1`EW zlCVHrBA1od*>%1!5?BsNdR(yt+zq}U6UuiY=67NB-nAi?z(MViR0fJ?MvpFizI1?( zO<+R}X@%8SKcZ94JEvnl_^O9A?7p4UKMF8;KBQ@RT5d@gxhHURw6m7N7KGNs2pu!l zcbV;h^y%K`O1+Lu%tIhqf5&E~*OWJO^?4h@A00+RF6$A}=i@k{)bab8#RpBYyB?;G z1XV;t`yLx7i2m-$d4a&!s|w4xm%G`wfdq>EBWL9+?Kja@)ckLQuR{!>%Ep@t(dEU~84cd{dcyD|s}f}~DzOTXH)UrPExBRHIXO-3>KOaw98J$!ec z@U$b<^>~-N{+Nn6;TZe-?DVgxc~BF`S$HKNX!~A~{tOrro<1oJ9g{(npZad_*Z|AJ zc#(VEPTEtsqi3%QZxCh3rIqt!if!Ne{ayE1HGSZ>>bFqW$1#M>F`+5^^z`l4sn_$J z%u^;?SL~2$d@}?e2XT}4w0;`77HORaeV(ayt&`f^JxuWn8Rvb@2~l|O+quX*snC?a zqwSNUEdlFBC?YUVO>3mZzV6|Dm2B}Q8p<`jJCxZ$Qd-o;^PznvlNzDB2zgvY za1+_g`-;kJJ^y1g4S4)V2AP|jAHSJgsGtN(--cY!L{%pZ`aYUI30jM7D6w?mKX&Kd z`c!kfTr?g)&z6@3gU`0#njn{+_|C33Xku6Qj^Y{S^Ykj%^T8|2dFcJ;pE&)!cvxQogdA!-X{;X< z+%+Bi*BNZom!42jgr4p8V&4t7S`_C-z{sZ0P`T>}*PU;J!;Tkq8E6z!d&GQW>TT^ zE+Xe2L6uf$1n2~njl|!1=*+r4;QW4Kh?OSYa$%Su%UiZs-{tc0;{pwz8zyuOoX>an z#_dFj=B=AGuE0g5e|A1;XLZU6)3vesoVM`AfK#ZR$6PbPEd+a7( zM=}&f;lh+;cb@e@nw52`q5XP&_se!-0U(@ zjSMg(#RnU_O>nSNc6bHdj%@Fzvsu=aC5!R_O@k9(n?0Da37nI2VtGhrxlHMQb#waZ z)fXoO+v~A)+>U3NBNa>ULz%SvYTDKF3gdtwDu}KT{ULY|Pb06Uo8nK`s6O2SH1S4- zU$5iay9r@7N@1a?FobJw|7=j^3_bQ-@vL z5tiZR`lQWbqgl?iLS_4SaJVeSNr#k5^1ycSUfu{aXRTwj5@N;j{kj(4#&mLSS&OF? z_KD#L+zBGghK6bxJtXYZn|`Gb$M>zeL)&Fo@f3Z1b;k1KTU+EzUku^jQ0X*bwjkuMP5Yt+Q_?`OUPd1TKBmJ$Lnvj z$yl$&-iqm!$V){qSf#1~4zR zObGhZ9=}i`kz;&}-`CxFU#i71!{F^RIA8_Xd4?ep53EmXYxqrLg_KLYEs?2{+1_-owY$w)ENV`squU1HKBWe9ecTdc#uPV@bb z=QN6yteR@tQ5>^~*)&P4U0zdwm=Us0Y`>DoLlkjtcxtbkaNm1OxcM zjP#Oq@%CurxtHh@2Hss-vd13&lURZ|U`#5{)y#;ob@e;lxR%E^wLyC$>EO+AwZ^j!-*gI3w-foW@hHALRUo{ffC-4P z=)XRDg?tP2vHtMC{xkw4Ra%W)lPb>3o85WKk?CE$cZY>XSf5qfKw-oTjI-d(l@`mo zQhR)Z@6peym`!FLe|oBazR6rC#RTVea|Gay&qUKpQod|D3sqbu$j?6W4T@4+1^9>z zMY2MIBiDVmM45d+F%}!2>miPq#(AIY!h%>h#Xy!!>{YSIo!4-LCFTy?4sn?}5jk`c zT<#diWO_jEV`ZCuzr`|nx?+43NiM*0#<$|C{b2aHh zWTq3Kl9gZ43FJ66CT6(b8gL!mJL%_tk>KI64L-x5EXDZPEC*>6)SxomwO~6n_lZ^^ zeo$%>tg7z%=7>=}NW-H5T}sKs8t|&o7od*=8>*V&*?t_S24DtyUe28^9%C<-$^CK@ z0&mnYV!U_WE0eS%ZfU)Hwe?#*#mP}@?U*cZsBUJFk-p1Cp5{zMB-)a4pF{&50B*%( zQt*t4)7laxuWotQ8h}7mT(+2;l*rPT8xyN@s<~3Kr)7SX0C-ZWPVDevxf*xfUQ`cre|VR*T$uAP=!ctbu;%^7h*-qUbe-7xuYiSaZ&k za(R03HHUHGw$U!pXc-ABN~1Bp#|zs4yOpV^VWrquZvEzQ3cB4M8uy|6fMmv3UqLo4 zO*@Vbg~f8K%v}Bo;*la~@chlIz?_MxjXr>6Bt!1rN7Z-EDXF~)-$ksHhqueG=lHQeu|>-{Im;^GwG z88F~6=0Pd9b@}Y!_<(LbPj8}B8FuCv<0X>VFgWw_G3hs|iG-!3DzKE==r>@~vylE~ zE!bCIKWCjqIBdDx5a~Ue7puM773%5r9^3Sv&?}1DOe}GtzeuFYGp92QrW(I;n*Vo6 zIajxgi=H16sN}fjtmF2dp6@iODe4Do$MgJ%$?RK8sas3ni+-W#& zda@uRQ(&jzR=4A@d}4D%YTEKFhfn{Yy@FI^+B_3ncdxlJi{^UV+-+~Fb$RnK8^m5~ zoORtYOVVIX!exeG$7C!1moK{90=G4uQ9wI+?y&mq;l_!c^kxkbw}>NSX+D{+h{o=b z_3kst?k)sCdIhQdCp>H0evrPkcuWtT(1kMbc94s`potfQd)Dq&_@#LZ<@$LJZI!kM z-fD$JB6cs})Q}ZBQx>2`?OGtvHK5n^Lhbq(aWi~W^7%$lOzKYj!Zaw8hd?smRA0Kg z^Ib6cT?Y8<@hJTcln%c<20Z)7JRvr!A1e_l3)0)`fRH$%kn{D;BGZ7Jb;-ALJ}DY9 zw`{a|0l^2SM77ZRmFKN>7~j*2GY#sJasbVu++&u=9Q}^PO-N=*v*||q?kkx_dOP)8 z7<>{z-hW{eh$!bg+)e;Fr54x(X9xH&gIv}(uUEN4&OBtsEqrjdcZb`Erwxl?^QeQ+wG9+HsWrMH5rhydN)vW27`5Yf*rgNY;` z-7z zGsx}!A|#g=Jo)t+wvvOJH*sQ7gdJ#PKsVsf;FC)KJZv0^*zUG`NNsOfls?Ksj6I&q z+*gY}wjy3$ygDig{^kGyWpH=*JrhYnSLdH8K~PZd@%bQJraz>M~_BqGZ6 zHnwE~xBIkFW`uVMU7fINJZg#P)aG8JPVA0L=4q=uu;-*VD*mp-RDAnH3Q=9(A_!Yr zqHpB&K16WUpCTJqoSK^-QI?#H|{mouxahv07o;Z(}?rWT9i zcG6EW1$Z)}>4;I&cl6JM^)~6lY%a|7L0L5O2(?KB@&~&zPake?A$JSi4}vZasse&* zffoc_XIrryf!6}%mjcJF@agcpT{6_eG1DFi2oYk6$m4k)A$|aZlF0bR!c5~Tx?Dkz z`v}$tXi((eJF)(!d4M{7L2QupZ6^KJ9o%$dKI9moqMj)8sQ8R=v^9d&dSbfyK=(W! z;TmTsf-rubRFQ!=9L(Q!(LdnQh1_W?+_jHKVK-ddT&$cECyLze(?8R@-W+SxtvcVv zL7(4Z`J|sb4Ck4*KK8mC2>Q}0K5xoAVn610U(WtV|6DqTT6`3mJd@sl9834-Ja{-7 zt5O6Xvbo5Z#Xbd;wx1dCiAEyfx1J7c+``6a!@*cNKP<(Gs zUFwfaclS<9GN9d{6yc6D>%@$p`%=W?$I_d7l&*lcIqNd_*!z#qDqnQrHvxvTcTdg8h4*AaKYCJ%lw=0z zJ@-0z@?7-a%`5GPhL|Hb_^~OSdPY)`w=#Isqs0dVI8R!o4{nn+Op(-7vP;t^+RaNk z_0+g^_`c3w&WsRu+{I<7z{1*QI$|&Ck8Mr*(s4J=We)SJR5qRJyDoN-C~pT18H~31nM6VvxYvLR^SY z-Il(@P`O!GOJ-}nq8jzqHxDWKBMf5otLX2}`ptrm!e@_dY}`^(*bQcrpu9(>OsYNh z@y!a7l{K%lN+xwXk3KQE8=}Pzw&VzynqxnPfl?r$`7q0|!-RC~dXA%tF~kClxC+ydxg zP@w~*Jlg%VlAtTpABj0hS)@a>EHI%ONxixdUzAt?6etC1a#&Ms_B$FP^02v}FuKG* z8+#Ia(CEyA)Klhf^S?5du$0cu=Qy08ah7}{U#{mq*dcN~U|xsb?uNvo9CXqg1|gsc zAx9@0Pv7n&J;V)3hY~;R*|~@R=KJmD%(gJ@0o!liE6|$3jlQv($~DUc3KH=~pB;8q zyB=Ip!=>_ZJ^#5?VT^gl0%UwW@_4(?qebR2C9nyc=C|Nj`3og%4!#!NaoL;iTD#?4 ztEj~roaD$1{3-sh*AD`}3waukE!>jEmoux)yL%q-7(O|5_;_MJ(9#}v!>+_6#W()r zc;0r)SYLg@DNhVJnbmNUQhZ(9U~%tzw%#WV%sq>A26jqw`WQU<|WfTV<4) zsV3xd^5*KKaW@vgu6TV-sX=>U-ClfTaGe&=E^`8LaPaO%k2Ch|7?Ye;3P~7f7uCBAJqAwCdFS7!(ChPIDbbICVz z#z?~7&E<&uPks8_b^a|IkB@{Fxfi|*7OG!01+|i9jxY&bPBuT>o|-@=o(@)=(ee@~ z%AC{t3)1+sXV&7(*?EdKohk+hUUS9>+rt}5^?*b?KSvS{M+uX31-|9RJDN(^w7*o5 zo?zPOOsucXJVIwy<54&L#=Nl)cDE5NM#>P{SmWz_5un+ePBR zGl^MM%ZBnByM=GKbP#USZ{`}wHrW`|e!>-YebQ>Pr;l+#17T(S!VgMXXwHgSq=VWM zjNrV=L~!gwKH5LmD%6PA&Mnqb`S~sMgxLc8lm+RO`yeHn9ZxBXAu*eYZ_*fqkD>9I z(^VIn&b^KHf>H*x*InMeu|y}_x3bHELrO{jo1u>wf6ddKtuOV5MU7_7-emu^Yt6!f zmv5nqjzi4JLc}*%=OHht8+zq4odjvxCl-(LwswyDEApP*gjc!eE^KN}5cEM>QyAnA zwiNE@0%&mVGo{38X<0I0CEMHviyH1HFcIsl5{)xAQ$1Ff{}EBLylo&4YK4xw#wo!} z8oZgDghcwT7v9qO$@$Q)_;D{f{03omzf8Zgc8)~^T7xLM1cRxpWhM!3_=nCg0;6^# z<0-eZQz*`WTPQ;JZ0``{ZDU}Y-<}Ve`hTDAI?sT`%@Cophgn4jZ55gN#YwU_ z6F~6gb|(ahrj^*w8X-fXuPOWGD3^0VU6%xP?A5PUWCwk^woY(J_^BiE+IJqc_FXJ&{Z7ibKQdl1g>KyP?nEy0Ou&(_e9-5 zfM`DVt-Hbz_ZQ}xTsFB{iUGQ16)%KpdZcm;1rfk}fvd^BQHX@d_k5tFg07lDQs zzwd{i6a35?cggz+(0?$hld$=6zJ`Am)btsW_Tr0DA-MFDWRxf%`7o{|40Fqvbcl!)_ji&Hy)uHWlrjSkdjX^GYr+g;0`5|oo^V=k#i3+c0pC&JT|tKa#UP_ z)wy^al$LnE%PAwQ2WD;>@dGkGt}gdZEQe}gVvdkH8U7-37xxyW0NS@ z#o$mHCcT)%Y!JrCLWdB6?AQsdWa`FS?CwjugmBXq4#XqVO?EG1yD`NCFL9Ma0s0sX zYz91z#EITK5yD%nWP;#@KT3eIAxGY?t&xfV{3_Mc)!W}JHHK!{0|Jo(yO{d4uYbhi z*6U$dzReqHr7%_vttFHtcsHTrI2DzN&A)_l@zkX1OTfjdiKa>&7!|`A(DHitp4J83 zW0~~#bo~}T5W9;tyOx@MGwJ-WKk5*a@Q1&Fpps&~#PUaxInrH$AzDW=xGr-CY^>q>{&z*6e*k`0zrLIeyg}2lWDy8fj5mrM2icmwQ9!+@@9N++U$er^ z$;f|-Hc;sJ#U!Ld4Sb_RZ9tKGj3%;6g;slUhA~p~Ij=~G>Q%M(y!XjxK~BbUO=RTg zjlLDQ<6@&xXaVp|=68B2N{P#$DC+IYDe<@GE|}_DwD*Tz8#7cfTGHov*bVOrtBFb-+oL* zfvDdCrj`aSqHMM$mjQ;SgcQ)jpGApcJXL<1yQns+r~xHXv7cKnM&yKVu5m!%>z5rLCv3X2#MmZx5lbu^Uae;Zj8 zrA2)pD_f~_^#}Wt;(ady*XHJ##=2<-J6CG!ZU+qE1r4OXm|Ek<4A2M zVBDj<%k02#Z78In9!65HL`7@y!!Z)#*(ImhGp59r8Jh5i0Yn=aWJ`nt((vw*B1uDTsK7@--|H3t^(0{`5x>6=D(2U#MX?y(z80E5+=Jb2@pHDNYXwEAw zy&BKk8t3OOLGe@}vmfblJhaPndHPOX{~bf_(-w4g%T0Xhiyv|9Qw#NZdf0UVUlUiJ z){6X*)=N)7gON2jSSEByn>o_G zbv`MZLZV9@x{y$)svV^MH+a#_-#_w`W0gf$%Ezj~1P1AjC@FF4YCBsOx-Yooj zqwDB@Y)MEpINv@?RK>hiIAiGDK)&+-b4)!aCZ$EfdZtUMM2s5a= zb>%xrWKF_mKKZkye-db0{aMB5B$sAf-@aJ!d939{gdFTF4x(CHAzG>RxG{P_(ksR- zLEe~Xu=Ijt4@|-}3yshwTB4CoTLHVxivpO6{1j3$1f*>w6@)AdZR`5}QAguezPNaz zK><5so2&^n0A5lpwnW6#tS*;hp(|WmswuEfG|Z2`zHHYZp7>z!qrF21p*Gr>V)7?? zt$uYKGEQU(3C4`n5)18M8<|S^Zw(&3tvrY^>qP_MBz5~ZcXpo*B@0XGvrY+^ujdc zK-CiJ*0m_3F>WtMz3jWWH@;L^-5ZA{udGGQolqCri58T7-)ZO*^*b3U4V3LjR;`wF z?o8*lNJG+6+&Owic=**RM0fnx)qu0@t8V@W2W?z`+dE*Fxyn~Yi8dt-We98JYI`=Q zmi-?)+4%2G)&H76>SOWm$-nQ_ERa%Y{t(qn#N5=+sUEd7_zsSY#hzmNRIvVjQt~P4 znRwzEZ1nXr|JNP{>>Aawp5L`-SzNCrV=P^F4U9M&#uB}~OT~U`>6P$BJk2D;bB_1y zpou0>mL@x)%9DLY|COM|pZtOeI7iAfR7^4#tNJ3BOOquSO_QxuhbD!VnSF;TjLZsF zZe({@J3ahwQP{)T4kX8S<|x;rimV?=@Y6>RoZBNScJA8rSX8hE^a|a7ls|p0f^(-8 z`8U5&&P9CrNn zr~@uHA~LO$-Vj-bIY#1>96@`~3dDhRir)+p9ZN|qP}lG{C;oAy?{ZlXZ!$7&+Zcdkxx=$~W+~cgvVbYXKQpva?3YQh|MggV z=W59r;JtQ2X2AloIz2x+6jj?`9C9H9yD~s&j~B8$aWSHic%tTG(IAfv&oj6+iEaqJ zN1@$gyqo59&fUAJ_MgdO12;%nrn$qI%bLXyyUW3vUaI>Tg%Xl$^&i^msp5YFo$Ty% zvAM)b5hVgj2~uK6MDq)<>SD!w5#W=O7dth|l^$)Z;WrKu6JNSYHSM9zaeJ*-(K;FA zB>A=SG%vp5Xd0bOddOwq<*N+u3>66Ts(Q-JtgG2$Z@Y-NE^uc7}bC+=5xm4n4Xb;9$S|iQLd9hfFjARr4u2qp@&rNb{3B5NoxDYd}87HSUKrHIb45e8sDn!gX=Q9J zy<|0b{hbotL!$rSCAUZH6q+ zqVf4i(Xr}TYBU^D-#3Y_V1`W*yZ71jCh;4X9WB)oQUtm=bN1j4ZL#Wu$hZJdle~*e zsvm(Krs>hVY7cRYI?5(uyt8c08E(^~RHY`zNUt_mVlqh|YS6me=x>g$r@48gN!rrd z#o=^J%lfj_K_dBEOET;;n2h&GR86zfCuzSI$qpR@YBivNL;uZS8%z+rE?rBOP+xET za#FcVe4Z<)p2{dxe)A-ua`k_8eAT~z{}nP7W|B7LF`pyAXkv|)VQTbeEVLhord^sC zK9nWTT9xKP?on9^Vlf}Ev0FyJv5+^~PdnrbjoJUEe%I^3G?-+6V*FZ{odNCH-9n3o ziH%P<)$OH@)ej>8TS4!jQ{s+T)W@wr7kZaLZK!Gjc+@=bV`0kT4>slS%me~e+FZOL zyQHDQeC%DE_qJ7uD;17j89k4byRp6>U#&2tm3E{&<_b&mBtIJ&lzH=`vgOAu&$Q71 zky(wOZI&{=(72Ha7-U_6e?(NNA5KSz_Yw!5h7y{SP~O=h<9i$=_kUz^Se(`(%ifmvPD(>ark`DqDEVOY~T4UVLj7G^3M$^waHt@1i@vn zGR}lvwoyqmCp_33jBj?X*sNFe_w1TFlv!#Z@blKI!NegBr6x%~AcGDQcF$;V;Ri=* zJRIB6W370=3DPSzCJIk<>AN?oD*mQD=7*iTp*%Fg)qlk5?DF}zeXRYR(p^BVP?Rsy z=eF<03%(-FA3ZaV7cEJ(B6A=8&uH%s*_RNEB2M(FVa^M_c)$j)6gjYLxmMLg@K<)1 ziVghdoA}Q<;qpIW-{02Iq!(i;21;R!&}e=b_tuBuUFs-qeaSa2iT}jhk>~YSe%^QG z#!hcO8I^sby8srA_3cOJi3z>de0nG-7Anz7nzt>lqVfCz zW(xDIol182(YWXo`YYKj2u@=coSduLgMbjX8EXjnL^tiI% z67Oc@SyUYs{LDNU=xbpghrHeHlf|_fv}&49{6pap{>Au+i%e}~X^R6>2#J&n6a|}- z5818AmQhYw;;A1f<3+*4JO9%9Snrxo`S7@W{$=Y{zLBAbGf5*4x z_a#EA>4Q#li{W`AF_xPp5udCuF#fZ#n5lIN;Zn`0XjqM@>6pH889inlZtq9A41zRc zzgLXxQG(onkD>}^-={xC70Wk_@6nK>z8cO{0cs`w+izz4OJ?c=9-wYF7kqUAc2r0v z!?~jV?XIe#9!&Kp;sR>4~#)ZzELou^ActX!~oQuj@!Mhg}h^YwxMza{tJ zAu?-;4NHs=S<{^`s1G+{^dThcBzv9xWNC_G%D$FQU3z02N1KCs#8Tzkr=7Oyl{ zsS5ZBRo&%n)U7k}SOq5EJmX%M1`>8O1Ia?$wkpzR?@3{o$0i5=-x}*|{~sD<;t%sS z8l5>Vv)Y!jTaW&ba_z-j@K`kRVo22l{S9d{B$l(;QSn-f>{HFZWe>rGBI8eX3su1} zF<=!B4{|I|GzPR|B#R>Ai;F&W32ma=2fG=mXt^M(v@avEOwbE4?Su0=s$W^Q?tNU- zDh$(NA=tiJ7$XFgwW`{2!%L zlP~Kyl*wIc^-AF!f0LU8)EiODN#Epi6S|5~6mzGp5+p|mVUm}<_(vOKzRuH%A`Qyd ztUeLtyWa8logNhhyx#HClwdygdh^jW{=4?ZAIZV(oV4*|aA=&~q@{S0e*#*MJV&Tz zQ36%p=bTxMN&ik9T=sTx1G<}^++4uEq?!|vT=Wb?Uw0Jr1MYN;KojcsF8b^cs4KdxdNiWm%dZGI>(?%$%L z$BymTR2z<#6{_WnmQ`{EJ}SINYK_eAXkc?5)rn$cqK!2CNh2t_^G~{Q?!7@Ah6x`% zv3483_Me1=6z`kuhTwvo3QD`5MMx`I5gVXH?)o!{f|?LztMr!y@uT|B&sw2hdczl) zbaF0i4@SmzXm5f{S?iy(M|XI1&2BIRnTKvCCDbX%h3Bi1iHP!0^vGu0>X{Lg66!tb z=Qe3bS`oiu-QbIsh?E)ivh+OHzu6U|-Gay)8CnVQ-+Zp7x(_ab+I#lv>emJujQQ37 zud3|s{=fG2hfnOW2zIXw9R2V7>JR(|;I*OLFq9YGF>V503r)Ph*$N@Iu@6xn--=V0 z1ffG^^~>By$GUon$At7YrfynBVw7|L+@BQsb7WwdFQCH{Hw*WU4%A~Wif~0JT(Oi- zjWXo)&^{N`qVoB_PyCl()LS+g@+CalE>i~LcJtVd9?^EfXlaU)XIuO(vxFdiJkTi7 zqi{rll25yB&H|?(a_iV85m{r2cc{(=l#kQ+hIC5ms`G*6tehjFh2yyfrBril8b+rw z%v&R%;veJZT3)Hlb2Zu_ks89BTom7aGcN84&GPf1Irxx$;f&oLd7&5K$YM`76A_AJ zZpIw<850@Z4I&XthU_y+HqH=HsZMxi>ww}TfFr?kNw7UZyHyWRqC?D|WG!Tz^iR8< zfM9*8QjKbispLhx5xopNGNloPZG?qg=MJ-#-QGzkX%|yBLHw`pgaIW?M4a7pkmsBt|Eq!HiZNc)idCq?BFVjug!)cxIp?oI zHg7N&C^b_{Q&mIhis!nzOl+X2vU*)bEiZsEf-MJ~mtTF|q15D~9b~KPm8h}kfj(xw z`_50F|2h-8R}Tidd2J_Vt1Aeh?#?H^aF0Na?#LfWAC&F5s{DV6(u!YRQZ8tfnpGB^ z7eh32s^&+6h%G23C-$cKd-3sgjjk~w2EHcdniAgx>0&I z@9Bas5=2ZM(1_@Ivd((D77zxV+kkpEipb_h;gA%W&&5sBH>6d(23_ zpvO%Ka5{xA@mPd=u*mDOSmRDF0cCoEn8B`CsX6*`A zp(}#%=+!~{B6>Nik+dUEY1@jVF|^n-HLP`3?c&xs8ls2v3~6G}_&d(^pK;8V!%rAh zSnlK7D-5OLDDMfFc@7OKIu{5ix_YgUXJlJM-^BWjXY@@a}NCrSc<^f$*fl8zd^m? zVMn9HLu)fIFvoGU4X{P4#xY)*Sz7_Mslt#_vHB7CmXDhIgqqEKH&D_>37x5L=3~>+ zPh8TKqvr8ukf;l`H-^D?V-z;`z6TcNa^F zf-uW*9hc4*+y3f3oJn`F(E^`Z+sY426?%}%uxzW>nuH#c^aFyx9`_Q6mk<9in-I!v zv9jGpq)Qb1>8D|TF>iv8()B{Fv5hC|r6H4a(@>D8jP#CV&J=z3*y6r!D~`zCPJ|cf z?y0GjbRaUwctkY)p~(cdz8U$AzsJj_mJM_O2x~hPu!anb_5Pz zE9H-{GhZh4Fe#&zj$gMLXPsM3UjC|JA)CNi`t?q!*wV?^JX5l1O^Ar-_m5vAte+f2 z5)yump|i5Kk)|>3wEnq%0?kTpvh4lv>vrFe=h-B- zLs9o@l6^@OP5ibdw||>%h<3E^1FAX!35l7LAE&lU!hWL&?nq{qv*cx49p_aVdeYM` zE4S9X)KiQYy6<_Mum+U>oai^_XCLv^5@A|D-Q2 zI8l4i2JdC-h+cd16>JBS5q>spk6|W)(h|D8LXJx(MB}Xd+xo{by~Mmf!hcVWA@eLZ zwbb7J{X%c0*6o#NVGQn2bCBY*83cc>`f7RSo8q!1 za!zbuE40|&`qL?SMAxQAyqrB%MRJ5w`>u|3u%+?iA-6x@O~TjyPL{Dp^VgL|iS%nM*58HA>nTan zgTolq`q##I-#PA$eO)5Pz$17%#F+>XDvz{%coUF7p3^8KvR0^{o7m4-{1EYgn;2b2 zk~Mt)U8J>Dv}9jh&mcU5xZ!NrW^gfr7+2(YD(|EqDQK#4aufv?iuEpfuLC&%a>AeL zS2p5ncSFyFj zhTqZPDC98*<<_bLVihrhKu@s`w%+RoI;N6V7d^$|>4PDJ3l{n?|l$iTm0=Inj*IG2T%WvWHgP95i>de2rJR zVle@go&v05stgN?+`50bX={V`$NbR|_NJT_o?^69;q zffXl6VhGA6G0fxfjn)+%+yxEC4IRw!HH*5Wv^dMY4Ak^`X*nf zBLVrs<_Og319PeUmpTn2{?Z-~$t^LczX5z%Hdy^`Dwgj`P>H)-RAM3 zq=&Kk^_(-+iA!${9Z~sSfS!ep=ATboPf5oK#SkHg7ifE*8jzvfW?8an!y4}=*lIrkiHGcYHa(ie9z{Y8X4BCLfqRh=#JNFQya}iNd=xEm7m(q&DZ|j!_I`( zD@^j2)#1q>sFguL_m-XRr(IzlB*<5-R zldGx9W@@&aR9pC8QU_Gr-)ToxUGXnGy?g4Qo+Cn+Gyu({7^&br(Aw&D@kjaGS!&9QzothW5obi7hr*EI?YO zEOFwFrbUd?7ENn(p$|Y0Fh_!2)~*1okY259P5bk9;}B5m4Q_zA`PzTWytMfK)B)+1 zi}yO;<2E>`<>D&polim^8O3KHP-^|)rSK_k9dmCzfQW@btzG%;!6eD&`<3_J%FwKM z3IYasm2GW}J;}l_FwOymhz^zB{JUnR&I`KL`L6iN`3S@2%#ih)>8?wrP({IVXfprw z=NFVpS~~BNtBY+g-`)%tuIW12?2ZroXkr;`MT&q0B z#rYV?hTq4HFu3rm^QlOQ=Xrct_BodV`{){u38QKr znmAz690%;raVH{NM&fkyw*j2=j=an(i=?h(!s_f4m{G(c?aVlIp>{*c%Nz`PgMhIJVA#PxL!wTGv{2PxksBiWn4^+lKNaZBtW4 z@qZq;1gDkkU$S6mpmD9SrK4pbC+3BlZ$$%Uc7T7x)Y&g=uaG=wEAKBjy*8*3+Cle< zUopEyni6%E+I;BeRk6JEk5ex$JccLv%I`ZG558RSc&*-RibnjU4*XG3Eln@cQ`*(l zm0k^Z`-fcD^<4wWc&*jr+GjNcz+^;MfKKUJ1wN(;7iGGny7+~~+#PoF-0dIW>@ZAd zFi`_}aBE5BAvaFAUUm0#l<56Ad^O;gcA$l2En_^mxKMj%$%ul|u8~PfyqFzGR#cnl zybshuRe$Z8Hn})Ehx!6{7Es@b>5ui2W|y~XKxH*{Pd|K3((*)6x_9$1Afc&9>KQ)# z#H;mm5Q7rn^Jrm*wHU`3T*0aFkbEf4bww>&25;r&Z{u`Odd(wFn!hL?@3)lmWjzY< z)%cE*VPbc{&?nzt?$ft6OSLl(^>>MMSxc&RER;wvTXOK=J3ThKSm}X8mBO6vp0zbL zfYEJh)D<8D;$b0Wj`~UdJ8^jSg$K)TLAFHIOy>{tR~Zp#6|`F|nI-t_SP|P3PRGVW zMPW}3OxRPzG3*}p0nwEszoI|5#|Tm>ds<^mzbl(BjzG4xHjK##Lv1sEALmo|y&C9^ z-phJ@D`@k}b}}Lb#mt!OwCsxu21?#2Oi1Eq`xUlt%5}n8b!%zeu>mD(Zg9fCow4#0 zFPy6EZ526_LVuS2e?5zxfZy*m&(GwrMF)MzcJcJyb(>fO6Y>9J>n+3D43}rMN?&I20|=;uLRzK+zz@-Q7J{f#SurxOo){bL{>% zp(5V>I4ecFT@5l=*xl0l7JVb7xsO3u*-1lXjsubbZGd{#e;hr&a*;ifNRclVFWEbc z)1@c@q7u`+-Ve3Kc1gOE`f)tw{bp5@NMn? zg9>A2T`FH*mRBYd!Ktajlj9lHtmynvKUwxfSo3VPSUg|;oFm>pzty3aTbJv)Dad4F zOjFJ}9C6*6p8HNY>O&SA)j#|^&t=l$Mr=d91q)itrUSwjA^cDMtYIz7pNeGISO6ZF zeSx#{#M+c4S+Xo1g6=HN1YZnN-CWF5CCZILkif3}fH|wWq93Vy20rKqK92f5Km4O0 zLzs(tJ1z!nbRnD!`SUh5|2(twi)k z;35!^iO$hbrU(>pNZGsloY*5|)#o%F2fxqn1BrV+KADAnyq72~Ej({qzksX7{%2s>OK~*I#(7SMJQK=3_22KeT6L z@bZ$+f@zSKH)^4b3OR2E&M_dt9vjEH5BXwd8;iWC2Qe>-WKxM>^py+83jV9s6)d-OzNCUdSt7Q!~Ff%yRUrPySlB5 z819a)$kvy1?}$>x5`FF)EW87sHW(AYE~kgOk11#K!zqk-x{di)SZ<3muBQj#CUm`w#(* zRQln)fZ{ncfDkM!%D@QKHd5P)ozTd&LXO5$d5+o>JpYpAW`1@%o^26ZfKX!D;oTdVpTw3K{(B}Xxb8s)z|1_SmWK6Ro(c)9D<%Xd60#tGiaK*~2j>>7U z<^e`{G%Cs$%Tm?>itY-D-W85rpS~LWA;G(3_&W=45l$eG{eiXEefxirr2EiQSDmJ) z@$P+bkFq6cGnb7Mo3LPj6+=k?i=$ba`y0SvLH2Mc&hajR;@a+D?A3Q>zDFX{3TFOX zZehpJLTVK|#wvMOJP)>%-rBKjw}z{-%k8v{&B>%EdVovtwxeut zRPftZak8$I8H4^$U)?ZwQNG0NwNl;bP4W_AZ~w)I)6Iok!5*~%SwsQvY?$x`;WdqF zsjR3OT}U?eec(UOZ41j^>HnhELQ>2Xwj?BWR4-9KQrAe&=r>K*Pf}_Xk9iW~@qGo$ zhlHd8uAF_*2g{g$9e!vfk3t#=nPRnIo~ww_!VSl;lV$96EApZuAoc%MC-Q2L;#O__ z<893(XvRlqTN@~fxKr6zV`50QSMV9AolOP=$Gyq7iQK}IwKJ^wxR45P$t*a+am10` z3b=Orc^q3wm?>HlRbKf`HT@a^tj$;k1u~^Qzpod>DRgsUhMvlELYk3T{mUVLuIpZu z8u&c`XgI51!C36q8WRMnyXHid$Kb?>W5yAe!NaYs-WL~*5r9s-*19R0`nN$F&bf-p z5eJ%ww>sxypdATD*>`z&HmAYaa`K;bE9MXw#pBxP;!cATs*SP2?+K1<0*QG;WQ$x) zn)nd^Z^2gwFZjf5eFtTJ+!m8Nw!0Vv##`cT!VXkwt!~!7P!7u zxC~pyX|0=ynh!vxrjfRAB7{pxM9s`4(3G>5gtxUN=NZ3^EmG3YvgcgSojGLYGyB^_ z5Ey+b+QUs&e!CkHS(~pIP)zz7W-p*FhNNzRIP;F?C&IhwL=x-k4zo~D)EW2psPxEB zl&m!C*7E(l_JUrW7dM78Vk{~t%r2K?^jK;O5|th z1$5xea7Nq8r)vdn;or5|JgFfu1PU=))GEyGi0UPH;O8|_r|450=by*e+a!#&Ahc!` zsJh+@fiuCaPvXxx__9R}DslC|-=KJ{;m!l|)}hf11TLbUrC<>hf`YLQfp6Ug?s1v5 zkgjyZl-p&T8@xr4i!&(4Ev{uug>=BorvbPDizx$3B5IrY?+0?OHKLp;jo3I1;} zBsrQDFne7&$8@WV5v6=VVWqnEk4%NJ+2tn%-=?O>*v)DbtaFGgoLU6CW#r!j^14F= zx5g+XabbL{014pTrKo)87LV)$lMyW{m-DYL@BvM#PO*);&Q3hO(|Jq=;=jB$2?rB7 zR+MNze%Qn_W0P&E?JW5St@bfIuLpuO+s!Luv|^FD!&!)GEXT4(U#?n2u{Vx{2xh~l2;)WE4>CnNN0ITV+8Elgxye$ZwC z*7s0765v)TEo-2D(U-EKn#ig{T+J{txdFg}^euLXGL3$?Bt^Qm0*pmIL+(s_rnV_d+A?af!J11jztkfMHZ0#h z0BJP@0j!G(c*x(H`z{nBw?haoh6xg^m(w)-A7_1T>+@cuo7{CIu(ylMv!`?ZHvuGm zyv2a4z-)$6N9jBHF7ngF+5}iZIyn)`>C3t|ghlw{DI5^zWPayD--zt#Aq1F`b z$J^@!jMO*rTHKqMzs_vx;P}xVL4`Y@8i{oxC~Mj<-r5NbMLMQ3mi5e&nNlSzn4EqR zeM5UYj>F|Gqy8GWrFbX*6S9(&5>}Pq=wuqIl{uP45Hk&98;St8_~NIrqZXTsrwH6` zw!gpXYl7gm24ouJeSj!nQNHW13^oPBGc66%A}?R(n)xjTa>m}zIH91ch+D3*+(1iU zREm~E$D>&EKyQ47JEguu)~1-j#ixXT`uN)M1jfnV&0?ndh*h!v!czgz+LiTD-7gH- zJdpCmD?qXH=@4znuYmf&7u%xWyy`u7)o?#hV&gnvPHopgoB7ACcr2$V_JiKQWcWY; zH_#cL(%S}+=^8lE{zX42EwqL-gd|3^y{)emLuhul`nb`{O;7DTk=rHe6i*D3PqUC1 zeXxaSPJp70PZL&*ta;Xlwv7uO85nbZ#E z8<3-JV3R=&vO!c2?QzN)_||8gpU>yE9Gm179Q0?RJ5&>Ln zpxdpYhEv~`*J2KC_!%LYYr|y z(Ion$d;Vb(!TQ7J>jX^n3+%Qf|8Po1*$SIJ0Ah%(f=~tHQTGVEQW;Zq$($|RBRpU9 zdD25HVVoOF8!_PJ!gLJ<&FJR5wFkmzcJam$lN6E2%5rxZ=d`p_7Ef3ZZpnF&olL?G zn?7$|=&avP+h#}uBf(;M9B&gzkVNIRb5Jch!hXA$k%B?acE9DtW$MPDOKjv#{dKC) z%5ioqxa%DwfjVKJyp)mz%YGn;pO6#EdAA<85efb|(GBn{H}PQ~ETb&)dLfO`QmdPF z*2tw%l=Sh71zf?ihMbdD>QOAbkv&K44bDXv^{dwDFxf7>D*=K#T_)Y(WLehHot)a3 z4y0ZZ$~tvJbo<`%TavgZw;RfsJR!Q4eV;hWZR+(@QDg}21=YXmM~!gn{OO1q zS=736hz37a-!>;YTE_!*0cNNK|1$VC12np)=AR*xcw}JD7>xh7QILaT`jc+y$!6bo z0rP3GX#S!j(efq1A_5h$oYb(nz*!vRpOh}f$tv=Vrg;ZX^?poqW0W7QW9>JXWg8}> zH``24**JHol*cxof*6!DuaRsnv08^|wKA_s;DI#sO}_komt(5ZA!5UJjLMlrjocP( zIak`k8J+F#C@Z)?0Z5M*Gb-gP){k1;_% zSHBzS*u2Pe$B{0Lia25sV;1%W!Oi~z{T~tdP3C4=s-#B_){X~=2LC29uw2hZY;lWA{_M=)L`su3GS3veuLR;Vqo5Kf7Iu{= zok=0JflGo4ekWuXgkJKY>1aoqkcAL#3nHnff|7p8M2WDe(q}7nJ~h2@Lg7EiqF=jt z8}q|aCIKnyBi6>4HL5dGK?tTrPO8f}R>f}2tdW@WJMp~0zsfpEN@Yq==eNjJJF4Am z`sd@}c46ybw9JB~USNrh;M9rmmU8Z4zBDELVYtIyS>Plf)f_w_LFjY{T*W!7sAU^A1IsHV1Je>ILWU39>_GeYzY>I0ss{$)d&Zx{OO zkU%$7PuJP>3j77p`2_kdz?5Kods=1A|l3T#MdW; zlDeuuP}@9B3H$-)t$ri@_MTUL+bIH0O1YCcmDlynjrK|93JziZMp9oF-GBez=l@gy zFCV}am@3~?*bnVGGQ2-)tGVf!x412nN(BGR^rv`C(b(a}hhi5Rdm z&8!lO9+^T4F)G(BoX#npVG!lUcLCSg1+fliDiA3xI=>PBV~u`crCFq-n`K5Ef6pDG z<mllgori-O6_vG4_jEBDXe z$uXaIa@_NsFBC=@K(|Z!pv+(`LfsdvASVZMrm{8C7~);+N+aGP1Wx=6LMXG^NN-i2 z)K+jQ8^T0P6H;1<8CaXC+-wJt0Di->ESllxEtZK+6Z%_V=rBrKf}`_8pM+jeiz}~Q z-rC^yjZCPV4+$xp&b}B3o1N8?g4}%ryOINp(`wcKgALT6n{z1OTo<9~7d+(A`FGsP4@8X*BPL1xzkvcnA!7ITz5VZ_l$*tfwE zWZ}`Cw;VCEE6elkkyPi01mk*l_0wn~`xWy3xC&qq6fU)5Q4GQnmVxTwJ(XEyuy>)7 z>EvAXlsH9G#sd_BPyqIRyZ;NFcKr_DbNj`dzD?4EGi{gxs(IlTy@{kR#w1C#Q+Q-c#B0euOS!A zdTMt}sjw9W`rec|cNr8IQDZHl<{|LaW{+iy&Mc>I5bpO36p(7Rlk6M8`T0KUducG) zwxMCKlCDjtJk$xJzDm1;f#zo?%Nt{)P>{-5Be8kLVuQy$lDXdjEe|13bHaM`>CR?r z_ybj5fz=Px?Hi9WlSxme(?S#2@i=G+&M!uS?wl~>gkoghJp-N36sGsr4g6>D@Qj?j zyu6OO^eQT^YGY=1K>zKXdF4WLpn7|E=0Y-~d_FU4Ba>R(|1|o_kkfrlSl>LXCyXFv#ol_lOs<>YAo5V;7n;oOgV z@5dr2`Nq*_+ci{F@G>gBz*`ZmffQM4M<%F=Bc|xZm$T9tT%)bjEUyqx1~y4n0V*yR z*CG%ChsttG!{>b77(YC>$+!rDC~ftnjxF0GnUGFiX_wOxzI*mAnHnNI28lFc;D7*W zodC7iS8{Dtd5Ps1Enc^cBHzRYQehO8`sy3@o6_K1`V4j%(h1wIsnWvBS4~5@$~Dwh z(+HW`-Jv9=xi~VEwXI${62gkbqK@3iB?>Ro_Ee=6S8?27E)l68%I)?e%#moZ;ndVG zxUO@GnJ7xzaqnX~CFh%>nGm9c4M@&9aUrfGk8RF;eoaGa$|rMJK@NlqNMjh$2s;vxZ4((@1@W-`h70S)B43O9zOL*V{#wX!mav{ zMBP3F>1+pACmq3=pGJ#lkR~$<(ppB8EJ9r>FLGn7cC{edq7j)+(;)BAh+Pf2C$?i> zIsZGdzl-#!mnCDx`RhNI=hh4oR?h}srfW}O) z#D6^;v$mqqFexGPxW&r1RC5(J^V1tFA6fM?G-o7Ogo7NdG@zdmSa*;Fe%GOz>~yaE zO~Poh6#*f>U0Gg68|||%M!5_@`cWoD67l|`L0v|)yxrfTa`urUm~c#ThKFYU%^FUL zP%L~RDASy1M25yfgulqHWVI*|wJ^=LqMb{kf$5zgGnkX<|uu7?M^M|>@vcaL?J&COM#cpU#z3&4j&e*aI>529cu z^%|L+QTkEyDJ!6*D?I9vcPbTP6WQE>Ssp`dak51r063MPRI3vFN0BK%yc=KD*36`2 zuBNG%HN>&Q&BQaCrtL@}c5IHU9WV0<34YlT#s&(RGAYd8O8gwKv6z~df(a$H+i{S; zRhTRGTKm{WKPhYMwJ=i}NiW07H}mXIK?F(zKoSH@p}3W)nn!Qg=- zj0n*PaPwM37A2pzb)bIy?s(=yW7J5(KcnxJ&gR1@eA~>E7e49e9bWOl?Z1MGf)jU4{H#sX zPAu#M#r@S|VVK0AvRuo&ML}M5p+x(qh0U)hgG(*GZ>fae^ zcEk>i>;mmu@hTd&WS=G8r>Es_Mrn7beKm{p_@nqdQ!)h>x&J*m+)Bw-MB%a}n;iTaPG%!Q1y%a7Mn zsXotDh%M_fpq(0XFgG`MSU?0TZX#JC1O3-4k^f-@ZvMjx7=13jHx&1rkdGMPNLKx> zUEg(%tSS(qgC0X!63`%^EtWn8jeI(0`4tpN<|uCtu45#!-clQG4f&vN{-3U5tb{tX zz>IFWiDzs%U^yij9@RE(y-9tP%Hbj6$hlFW>b@uj!1)&5fTKt;a_Hcv9^ZQlPYh@z zT3xAVMq^Hf0`aj%2SnKy>I&8)U@`JUleFdgACc0921@N zs5fBdczgU2qhG@8>H16EPPj2znB5d)#|yv)OR~>MACYVqi+B`9c0OsIJhEhU6wH?- z9LYr5TnzOGN}R=yv9y^a_q7ixL(K$`fi!pwY6g)!-AYSdMo3Fy0Gv@X=rk7iN3mD7 zy@?h0+55P%bW&xs;DNyGGrGF*`M4I2^&4KU!LRGo>jNu@-C|V+Q6dxAQQ<6eqUxwh zfA5MukzqV{Y;_hG-NfyRp^AV0WSKzsWmI3;&Zpcd;t0fu|M5Bu#BO(u;iTKT76w{E zso1f_>0X8BdrPp-G)jIf+<{eS)N>-758l^h_S~^t2%+ShHv#a! zK|Y~l5Nd%ILUAA?-?dcCL{A{=oFzl0gbX`g_lQC06jGY91o$_kor&wv*h=9StA&h5 za{Bo*Tlx{Hl#Y6CgkD})g%gI$ZForav}i^}R}bP#Zm`L>NBIY5 z(#vC#?^|_5)oFI~vNk(vp%yCTw5&%_9muR`^m85VSs@EB?4Mtw4KKiDopwM(GO{w|tCW0#At#fCoQVzzdTc6; zwwKaS4(2~R$4fD@^r!51?FgUvWVmqZ8ZIPbi0yt>57Dx+5xp*v;fB^ZK$I^b?ggwb?}Zy8dL7F(P00w-zVSCxvs%v4pj}%f%}A+dh0j&6q1} zLIi)?*om1{n0J?mpN-Sj*y;v|^5CeMlP?@oaVL$Cw)=;Bg3bEGBz*1(Jg_zdAF}_4 z{l9{<|1Q5b6het85F)0?*wnf6OBa_}OX+;~_~U&HK6kRe=!(1y;|CIynurx0Xy5T!feB>3Qfv(qGU@X*Vef31P4Mp7F-{0M z1|-v4{~mFHT8~1Nia{1A;CBk&Ic8e925mNL_qUwbfavP9Q4C6-G;QRA1LG)47<8&@ zI41#(c+3*-SL6S24_j4M$+3{)O<22Prda8QkRaXI%C-(Fe=j%Du$PuYM0}h0%eaNK zL7m-6eoB`LZ$PVb>J48<<)albk|KEzZiK1L^}9Plcg1 z%JZniVLvWWr^}3%p-?M*!AEv#?64|d%h)8mi_#fX{y1_J3Ca@p+J^I1aE4Xw&jjGX zZ&c#DaEw-J+0URI`IxrEBZ<%<8{Mqs#?W5C!&8P;6XNS4O=XNGw0r6w|FZ3>;@eTN zs@87GQB)Vs<%F9S<+gm28 z;w{0Pe^?X87Chbk5j+KlMmYbxR)~uT(R@Wv4_G{!sr4z*MpYjgI{WPFzoFf0(}@gm z`!8qrz5|}7z4QO7%zT;VPPG$p%+E$!H6+ln=1y~v%|q4r8%*ewg_!9u$Ap>n&&#fX zGHt#H39L;W!KE+DMYxUgal~_%mi(DQ7+o)z@P{UJ{9D_HiNIv&hjQ``L|r-yDjnWY zpY)ADlD7l<+SK#E=}s581=I)XcYMDf%F15qqNc-k>b9ywdqy)oJcx530I3!k1^p5~ zxNYzVF~8Hdo(|I+?8{0-D}jl7 zB^g-tx*FqwV6?Kef7|e>m?Lv|w+@a>wCUYx=U(*7)`quTBSGwyibTxg=!41?)#F4- z^<&U1rFX%JpVR%QJTH{1W}>jMw)^c84iS|&>*UJD&|zIavt4TxQiaJjNX#RWDFUM5 zfV>1R+^jJBjd2NX27E(=A$K%HvqGE4aStGo2x7mh6<^mW-~W$H6Suo;8KKH3VAeg~ zrwXa$E}F4gCm9O&9Q*H6F09_i1H+bIZ@YGh^X^fuAHZ~v1$0|^FZKSn{}y1u{ulW7 zEBlf|(L9~Q)6;}fx8I}&A+OI6{}9Ee&6Ij9SyLZnHAgJo5`GknwQUB z2KJA8F1+75J|_6!X+%vMWcbA@zcnjGaon1KyHFbkV6s(iddigJHh>d)s!5l2CDG~Iu_zIrNC{2Qy>7GCf7={yB8&GegxN%=bzF{#V_P)T9#aQ~$rA`L;roaOn zBUJS^gz`JBRbr5s6MFzB>EdTjIZsF7z=dNxIXOEr`D^|7bO-Jh0mm}mJNT{5L7ae{ zMBM-2=U$)b@8$&O=03Vn^Qp&ixhz^)TCqE|<10_4s#a=}|?=_{y zS*DN^jHnKO;dxsTqa?1pddzuBmVJj0uExyPtP^gu!*^K(2;5~ePab=KyLY`(LC*eL z+}jPb0coFiey;auc6?c|1iSu!;~t(8dK)))u(kDVsTYk`E!g1tJ@tRK;)+RK5=-^` z=VYW+`#~%8I$`Agm*fxsIUSIf706{p*JH(Vq|_zr{k1;~a(&zdJEpr#^sga}qN#A- zk*TyDTjI@wzy;q*v@$t(iX2a=a7XAvMj8I4sf4Vid#Cviy?e^uZ1Ge%R(NE?OczV`MMuK!5*c8}$X zsID9$K8~olZpuxYM9+OXMw$9ceB%t=pu{2J$WuQwDcn=LDW{wjho5z}HLs9taAcN; zR~nvpPd|lF#FV1Vr^#D`@)PH+TL*p3f38exjlUT050!JB+Ck2ZBat<>7^MgF1&`PQ zt+-uC(6c3(DI6S+<}5p%10dI-qBCia5N)k1uh>NDfV*7#{Imb*`1|?=~c$8)nN*# z*Fj9h4@b+A=I#_wh=J6@*$(;jep1?!M_6YR=u5TltJ^d)G+VxtRTU~cWHtY1DDq>T zZ3d29c`p7IUMI;nOV}bjTG-d>+XWWiA*=JzBIbLkh5fge^SvCuGMB>%ejbirv$}55 zVMMQ+{`YiOtLrbT&*PA1od0wLyPnQre>hBE1*EP8p69wA^&S%G9tb6`Ga(nI&*ZPD zc@N{jd&SoSI^TXpSWntmV~BWm@@;%XOaJbGp6Pya-ZL|Q9&vCAh7-eiJk_vsRil6TinhaDWC)(K9*(QS~ywFGrn#0>20N5eXbrjqQz*KekvW zQq}Q`KNe#zsb#f+hLpi{{SI$toM6nlEdZQ&(r4ErQ^;VUk?}7?&KlvmCX5E9aYu@S z1?>w>hFySGq!15`)d@+qcW|4eUs$tR#E-`0Nv5)6lPye4rGAVYzS8tg{?ya+lDm4n zHmPzg?E>x6DZ;N2GduwS$s7Yir09J0jD+f|R*_d);DHHeJDsUDeFf>p&P-Pzh}{LO zbS8of5EZ?wha*-DQBRdD2r~QhhNUFlDyn@(!QLi;@k+(Dek5wQf$|*oDjP+{0fF^p zCn*)WH+$**%fyY~yYK3>Sdz1&9_`xI=T9{HLk^;>KS~W&5{!RvjkS z|BV}sUAGHOoiHsasMhlg&&y0>Q=-e>&Q8d((7Vm3FIBpIJ~;mRiNP>;^Q4-Pesm!kHJd7djcy3g$MnW)W#a&WE zppPPJP6XgR^C$P2ImU#R3|MWui5EL<^%Wjx+aS>Gubf3{o;K6rA#2p@jynuf86 z9`-ds6HV1(Kti+3h-WNvE0jO(?cXbJE*E%)Jik`y=_JJ@3QaZSAQ?8&c^ z_a2CV(B|?eSvxsNw)$NIU`KpyO0A;OYP=zMEyjcNEGT!$trz@$HT zVbQt{ba$!BOjYGGrzlvE^WpK!Raj?aQpj0v)we;QUF>T&q{?^jsy8ymB=w(}ZNQH*t-zuW=4-tM{{ zw&9My#lzAZt<+Q1yz&-O_i8V%^Gq1?@(r|PD$aE~8!=E~OY{Q5IcU<=rB7<`0gce$ zl7|ix)2H@Vvhn@vs^eR~q57^@)-1f3wL+6Y72LLRfms$El}^nN6863agmLi zHShC8&8^*Z)3wLPF`lmR=1yppt^Ib_V>OIpa&q$C{dLvGfIa6~g2D zLif7uKfbmmw4E$f)CPiCnt0wEbIuT&fqzJl1A*2@`dsPH(WbAsw6JVxpZkcts%Gn~ zk97Q9P$9TSGxT3 zC{jG0@e1B=KW|a{*goi3yTS=ezn8UfvJ`?JHhR7vAe!&awqIPgn!T$w+)N&f1vK_ zxy#Aq;MQ8l=lycBr=4w-H>y03q0lH5Gy@lCAkQa(xX#+QP`LSH9U&s{448y#m7 zYc2ZI29Ou`&Yr?#Q^m=(O^4APH%Q;pT}EDxvzPNE)1M*d>C3a=@aLuKXMT6uc2$+g zYd6TqCEq;cP-|5lH|;q|ju?B&VG$jIru$5&nV>G?L@FPlfoqx-5y z)cF$WZj$aw7ADpVIlGK~ebIX$cU&KQ%*ETqHhmDoH}RCFJ9m0r^L}@inUiyI0k=Kk z{JgRH6o3B=KTG(PJ5O`0>ksxPYs)lw5*uIX;xsf4(*x_zLL57_n6UQ$Ek`t40>^Ipg`sW(1^A&>8mZxq=0!tiy+ ze+w>)dkgp7^LcrWxb}{0CKg0jG<@=SvfnHUHkEurVnT{~LC4)68xK}2d7i0;uPd5e z-_2R(Axh)Q6O}4FUy%NJ?oGSqFYi6$BJgHbDrEgJ)pYZIkIBn3z8cItepX=cPb${u zG^hHadi}-Np-bf3>f5u9W(9eV^EG6E|FE2A_n~s%!xfDI)r)sYh#sV+M zRoY`e$Nk^(vK+Lc|Neus^|~p4`@XNQf7gPmuhdG`@AGiOF7n^!4-XHGrcWzw zxPO#&t$rNZ>dir5Cy=YW7vL-9>jfQ5&cy4mc&PKN`W4zWY5Kt7Z+ZWGf1mNk{ru`b zIg#eg8;RR}$t17+=8fy2=fN&d><^LAsOV2m$|7! zYhnMc%A_tRVFz>%HtT~&C@=e6$lZ%CJkzwSCX!x>(CINBU%D)e*rpR@4ZAOR@ebGD z{BINieou5$Q`e6rUD@8IQVg69F4s^czukyGj?bCqx)`kMvi>hz*7zQ$-Y}Ba|CEh< zwv0SJaOa7A+-Ap)xZF;Z{lN6Q^NYvT_w8OcVqLvS1IQ5-VY-HOSl)`>J|_brEdZ%q zD7k|(YsWCtpPq_>ZA;HgauW|koKEPU*DOo?$~*mVQTH{EKoLCCt<~3;pzH0hjt(Zt z2jBIvwM)Z>RdBrjv(DN2BgH?4=C)jF&ylN*2ocF2(R#gIn^o)M4fSDqCVwWL+lxg_ zojqLphor8JpGWoZGOEeiK~JQ9Tj7#}!LR#LigaA9mzf&Gw_Wi*?R!sMuc%q!qgM-S zKW)#hBG3I}6<_n@9(A?`ve8#w&ggdB{jVdOq*5NRc`m|D zyZRQpJmQMB6~a(=dj^6GWcQXZH11xORjQx^kuU8VOi} zj{yw)@O~SrXR^!Dm0G*@FOSEX#|ninh+R>{q36hO9EclU-7y)RchAhmA_*X-vAGJ`K!TaYILiy3Qr*Z&}taz6WoEO01iGUUl$w^ zE|8@jvD)^fk5Bv`&<=Nkg#2lWfK48VvAz4Szj^ZOS=Uv2IPW_HS6jyJo|pZT3dx)O z(|x!t+fo*7oBegTyDkD=cdysKzG(L0`--_dI}-6sm~3fXy%p(v=EkSPXcH+hL?b&5 z`s41{=e@phFbNj%zlgv3@r28rw!YJRo--}jTqBv><=1mZ>w|xN-Z^p9d`9d5iCp(i z{%@7ia@~u)0+8HGTkB7&p}Q3YH=n$@8+Ywli{`o9s*vjTUM1hy<^kQyNp&9@s6MZ{ z8&sNZ9Z0UqDjPE*kKUMzsHii7D#m$l-t*T zyrTM^(((E2j7YoZ_3X)=fZuZ?-M&N1nB()HBfZx+M>WOz^Wb}F$er&x-R|wF z)Q>6`WK+xMP}6%<$-7nv?p4?R=aP~Vcz%1KLVy!DFd2un_J@_Y-QddqA6%m=wB&Zw zidX`_dw~SKEI$r&+}B$BWl!hVpS=C!|6AGlzn;JP!fx_lvl>39cEaC;vyC6UW(6TH z3ViFVsKq13d~OY;7_}j&{XgP=*mY^KK+CdHc(>=i)aq#ZX1wfsYIYd% zA4zReYXpNlQCjfJC#+{Zv5YgRLrNj`GXWU=rGlp`5@Zy77zH*5LWDvDhlEH}hFS0A z_%oKMa05H>RzFA-XoUWwA@I_m8mEd#6Bk5cAbi6~?$Tuz(&;Ys5nS8s-{-5_63P^9 z+H5A9FVh=kfvHwj^vr@%RT#vZG9}!854SzKo_x=lt~!o`E9tG;FDHbQ>qP;?R{W5n}z(+7DZGrC~f=|unQuotReoVk^ zz_TGihmI~h$LuIxp{r0-Wl(5Xk zT8Kz)%n|ygx(xq=!*o(*dZI#YqwHuufs)K8LRn%=c0mSyM=S1AV#@+=6x@)l<>;!{ zxGNw($!k2$xl~83^bUm~7Ll)6?e`GR=<=?-1{;hHh^|&lexQ|P*X_BaK(W2gnzpaQ z(fK6BSUs`GLKQ5ov{+3J!_vd$)0U9m`5>UL&bwj{6jyrhtw$|;arYF>(>}bp$xu=f zSYNM5Uq-WhlId41b>4*zmow52DotiSXszU(r+BTw;kWnyg5R5P_zlZ51jsKpJx}4k zOtD0rk^60u-(S-Cw;w`*{nK-ZJ|E4Tj{>hCblD*D}Q14!l*gHSzD2!c!+JtE)1A0b_|8l;H%%ug@~ znXS_RO-YKEJDReStZt{kS>&?d&)Y#G@q8H}0&V@fZ2KsvrT(vy zVFPD5pApyYhDko8j}l*2#IF{Eo>FD6DCH;3tOP4n`1Rfe;<)j0d$i@SBDJ9oBdV$i z)muze*K+1QmxNh&%O|w|pu?6}JBbcAw2l@Q2%`L{!WsqTDC!r>JCqCqF}>MVD!Kor zq7*um__V9)OS{$W`@1IGnOXIWi=#fZNWMw+9Mgg-sNUl~>c{$%?W%ujZ3^4BV)3YU z6xu1%sZx5YGti6`2_A!Vub_hz>*du}KQYH-J0)u^!ES!!cz=&fukRN=pnPz6qS5C$ zj#)umqSRX`@{$N1+7yaMcQ~4r|Hhw8-^W=cyU|9K1aE)S!?{fY4bH%HAg$o#7%L2&O;ls!h1uxE5caw5j4~nTF$y>g&mDWBOOz7K7$^QuThmTuTps-Omq$lIOa}s>CvVobf>+kMDnzEs#S;s%Up_TuC+_z@Hm;>waiIf6g4(d z-?`xbaH#C^kaVcZgT8NCA}Vu##NwVKS)AM@nP?lIHI_gz z!KG%pGnhFB4W5|>IuvrUn`V{EWSfWbics(zQiLBkx{nWqrpJI)T9(HgSF;LvqQc@JDm08uG7c@to` zKi+XOqv~_1>eBXm@Z|apHW)$jGEzhQTrT533n8+Oe2-cO6JJBSF39gQ^ByQ+d+X2H z&l~tK`mX!vuHpYO#ujO629x#bgx6NeAS(gM;Gh7kAsOzU<`f#24Bpsk+J%{-CUoTIlM()7oAdvLhm`MPjpo%^ze6hO#Tb7wHLG2ER&Sd;G3| zILZ=IHFHAmSXY^YDx{C7K5?`2E<|}VIKag3*eu(CzrBjH5m0{+MONF_1K^wqjBKYLeVMHBM(bu#52=Vt?>)tEh(XyP3k zd|)0M4MKw1toU7T&hg=63W(OeYiJG(C?+k}R|oqR^-}`>8J75ua9>v9&MBhnIsKL2 zAI>Jhi-Wu7*W2~A$7eVW^MBl=n^H6Yp`rEge~+vr99X$yq%Zt+G?@3O)$V<(hWEJs zwdoI1bs|`7{<}VL#(;$OyO?CvHAV^17DdMD98fu~M(R`)AAn069pjeiv(&f3 z^4)A$J|dJ6GC~_1mqlz*HFMJZe9*Qn!ow(H0+3&~SMru^Z`2ScYarG< zM>d)55V8TqWmXFTKkJ_766j)b5>PRmL2A`8pKvz;g_yeM;AF^q**I%`u?40;vq;yq z**y1*lg|cqXB|Q>BU!>gS(2@>Cs!G36BBw<4gDZk4(ZFX*%;%S@i)#>GkKm6GNFVo zEY96kdX9Xrd#H|wQLgi~UnIVE3GTnay<1NA{Nbsv=OLmzAti4e|};dC%-mV_^2l4&A6>ifj^TqmB)n9fg)y(4E}4Np!Gpe z`fAUh`h8!St~pp1RUIwLdxi+lgEU=K5)Yswu3Y@It;_5>>k*Rs)LVCM6N*Bk^fOu z0YBmlrkTL^e_zMs-O>n^UfMZ77wJtGg<7K$C7yH-EW3Jo|M(P^WPt%UbcQ^L=~Sn3 z08I4DHdaBUKke(^r+&`*9Ji1+Z-W= zJ2h-iqW3DWejcsAIS^nkw4z(^lw-HxY_MM-3o^Wkmh0gZ2?|M}eNb+|z2@Yc?5L9T zGlZL^j$$vmb>IQsh#OR_IHoalAAagq+@Z1KS?EUs!OIKjeglYD7 z)j-VZx~D3E548t#<2?mNu0b?5_%nnj>uimS9wJX=IYQkN-qkRF$YZJ-H5n~D^9Xyp z*c*YGVCBoBJ2{cN3jJlD|5Eo`hxPGbfULM;dMO4TbhC@McTyB_jbZTUf_;7s2a1Kx zWCByX8AfPa3ZTqoK_waL>@;Ui_c3X2sT*Ua@^}MOhadxSf8HcCip0Ru;j*+l!aazi zb~gE+kb~TQa(~{*mF>Q7D#|LP#BLYWu`0!>gKYd!;v{eSXJGRir zq+#AuA?Vjwn9Tr~PS;_5FG)c#Y61(cEDur7I{d_du*896H#VkGs~+=eaF(>oVYj$7 z1;13Qqfx?->JW+EyqGOgLP|1+^RxFeqPxO{nNI55ufa=CH+O!P``;H;$J_j?$lTZ$ zzt0LNs(6zS=mNj|xvgzjzjLgyl+8M5Y-oeB-)uUb8l`t4-HQ)w$QjJOKOQTdVvHyb7VqjB)Ig!S}2Q@#dc z(eplb?7gTc98Zk5+&{f6AW&|4ZI1_Vi*Z&h56e@DUPrsro?zBj z%b&}Sdk99z0=u7ZG4^?5K-$w*NWZVT*2|kY@@ZScYf0ml?nOnij}Am*l=V~eFka3d z`8}hJaT))T#G(Jm|JQ#7AHevwj(g}p%1E%Qawst8(1hL8TPnq4m?O49+WmfNtWI^| z9>;`zvbV3G$wWb^ze=!cr278hw`&oThsKUI-B7k@i>rJ*v_*D-DeVCA!@%2-^Sn;y5~=}IwjN{Q*5&Z#o@i;;hAWsa~I{GEG8MX zici&a8d$f)fEG3y+jI`2x6XU&CCfV7Qe=ZSKTb$qCHR^78@==MVn@`}xT;1`a#>xd zx5{zE6_HaF(sB1%Yce=L4WQ~;Dt(aKS--it@dr%S{h$PE^gi~(w|2}2(O$MG_tRYp z(i{D!1nEHy7WK|-^ULXAKdLT!M_mVu&L9=kscn^`G4ZP>YYvyIxA>~7g^C=Um$~0x zwR3MOvw2C;t`$=1|7NX*DTGi_miOa;k&Mpqi(@88;{CLD-dHAcoM=;LWq z_9X6YGmF2ma+d>Aw;n0QiCUl);%8(@zJY8$@4{x&J7~kh>H-wPfLozv+OP=Jpz=Dj zaS4z-VZ7fWpNb6L(D?&7KgQj1&dq&8!)J_vr_3u;#-S>4k$dqB9qx`FXO&t!sjBtW z^0SdaQ0TE4B9JS--&+bVVm&p+hQ0ijzfXIH9Ab@aha7fhd~`9_Gb#rS=_WD`eCk*bj{5KA!v=_*@u^L`&8I&)cud}a zr&DlXXv3_4%B1;|iARP3Vrw`QRHt|HWWDF%l;$tS!Pul8 zAHB>ht=Hs^k9V@y-7mF*+e8w5uihx>nig>(=WSff6S1%IOt4i0(2JqQZasT)6m&t1WIo+c~M@FEWM+Q83#wJNAqYOS8)NTIMa=c$0bBZ5d!Fz#0 z0t5X5Ip$n=gqz?spdn4dLQ_w#UpQDqPZ|E)m6mbUjnz+)^*>Kc%ux3(etG7e@aV&( z)9Jkl;RdtU3Sj3>$L7UdMvwG5J|A=}WZOE+*+uucJktpg!y-D}FY_P2Qlyu|vK3o%{k+xE)8|qP9MCUEUGW&^`>syEVkuP(?3l|nC z5-hJ?qtJpu_(RXavz50z_CI(8FK0oA+BVut%5EsJF;(P4r4rszr=waxs(~x=M)867 zY0shTdxfVXH2p%;1ezh<3)yH3EukH7=(V;0t4-k#-CR!||7zRhAf>u~r%iqB& zjtEmfD63m6#D$k9XD)JLr;WJ%!Bms%{tRzyl$4(n50q_}wi3f0AA(>&b6ND#<6nh7 zCQXlu6x_E?PJghef~MGI53LE6vsZ`eU4p&;8pkaQ<peyWPx@BcLZC{hvW$28?$x|>E`Hf4rwWsNsbc?oHqVY=V)2Q-MAmoV*!U7IO#qdGU8$LV zeqv^40~lW|9EoRBaWB*H^rN#rsIWQF+R1vXP;%aW`n{91_-pM0i{jZ%gI(m1IP1@5 z1%Vv>R`p20%9_J%>P>HFiG?oz;&`-^h>T+SSS0@eH$33y;kEb0r|I7xv$A{!>8iSf z47nrRNa4`_$2FY(xdbMr19!B0%e^BjBAqW5Q2gjj$gaFo-Whge1-638%o4&tRGPw#CSk+i3ALyK|1^JH!rx{h?Z0nN77{!x_qvA_eI77d&1 zbM#Q*Ru89C@_AI|lJ2SiencUqB$M4gvUu z{>uVXBS{ZVFj$om>-=&3}mP~yA#rNhbTFt>lc+y<&w<{KL}@%U&#u}ntuVMI7r37 z&}C)IPwTB&1#a)MY&V^J?wO}yW!T9=We!;RGdAg)e#*d0>9IO!i0^tNE(X|s@ zO0S5(d7Sy}hn9OR&c|z%=?=`d?y3vwj)r^SQCu+OCwXj|eo9yWL_``kY(qB-ACOG6 zKe}C@eAuV1&;avTQ9*@L*-L zJ)Cqi?>#0b5EBz_5*Lg1{A}2ve+1`=u+Y)=?93Wps%S>3yEEi;xAwl75Hz~yE#DgE zvLWA-%_%ju*J$;4>r5fSzW~IlF$pGS=B_$N2T_o31~QKJRnf@4)!9K9iH8H7@Y+5G zoM5Tr?AnlF+$M^IAcvdyEm_>|ec&8336^JE$Ukq4)|-Dcp0F_P{kL^)T?^kR5dgKk zm^x-5zi3QbHS7=fePDL@J)Tx_(bo!ID?WSx7>2)2`-d5be7;!*MB4xT_^Npsx223c zBXcz`F*Vd(uWMflr*KM$7Q4HwCZftNIhw+=DnWVN{$>1cq0#6>W3=67PT-~vYKkhX4oFW_It$1;l0+2nH(g_1;2Mr$B%*O zMmq)7=#@U?51-m-2oWet!nr08cG-z||0Y@M_dnw+_P)_kf|RaH5=VGDruExtA_7v* z-@CYA1eu<;ioy)0F^+^!F(?GUPvD#4(z#OV&zH69u~#MLMRgBjR53`_`WyPWQj=PX zyD~G_%oRf_B>~1!9jVi^)?c-sqi;!Wtde8D6(P^tWjQtb-o6FYqXot2scq8p4@}&T z_!4c@YEJ71no&IU%wJI=)by_;@TTIli4#%n6R!iuwpu`ZTf)p$d|yA~qQ(5->n!Dm z$@+CgZNx+r=wBCKw}w%soBuue00b;>$(@paE;jS|6=1thH}4YHmO*1G`qEa#jmO1v z?ZM>5BIV!fk9PLB#i}b^nF6U?t_|4wScaWkJ%6^UYO~LX)4KquMY-tbM7{f^ia^TX zRSlEfC;k4_-+3Q8Je$X}XJ%sRy-P(kzjJ;tu^04eP|p^DwThKlqoh%&xi(PYL+#}- zdt1Yu_N6Nz^a`_T0*ueLwI5e3SJN?}L%TE9Vfa*`76o2p6dK0pcjo}F`UZMgE#y9XXP z(J)Qcu7vbEvBLjRE)FM2PmCfRWf(dzi9mfb1&C>U?YbDN1*mZfW@u^ZZ7-1>7ld3v z{5;RB7{iJQ+U!R$kQK0$K*6!zk~tw}`b{Vv!%OU!ujeLN#v z53mgV)#0BP)g0LJ(+znEc)XYb(EmH@lxq&^CVXl$C+T>kskw|>(hg7bMGM;gj+T5k z>R)83WiFNa{G~&T@&%6B4P&K>>NR_&)bn&{KSVSbhzCmiDZC!{1)fjdM^3uc<2)c1 zUERl~pq7}idkC9lV^mVx^Tkau>ajuRPHE&Dr@ei5SVSOfelD4Pc=^o+Ds&Mol>y*J zD<1GhP?=yNDv!1{#rL%q*we%=eu{^$@4K+|(h-lpZ;sIx)s=p{Shm)vf0_jR10-IN z>Q7E#Z*W~5I1_4KlQk|6)nSS?>o^KZQ7fRB9aLFx@?)nA?b`cJ+m5M9k|;VOEoS)Q zM3o7>W{qp_L2zOL3gK&T9u2NO1)&cc>+U+wHtJabR&=G%8zJkJfI zN{v6~aI!yGs2wlrRT!j;ZH90*deX(`v@?N76c79Kci5fcVJu8{@fcK*M#okC!to}T zf-Bp7jCGz$xM7~#ctpa+&V`H2+Y4fe4zZt#iTQCOUa52{J5$(E?GtWduePuW0yR@?l6-{3IGs?A^9)B zDs~?t;E8mp&-~}Qdd@J}30@4=W5P*|O-k#G#hI*^TaE3?om+FdA=#cVArO1mS3s4& zrZG=}*0)>(e6CkulQS@HCjmlTCd$3&bAEXam&fF3n_&X$mkdU%TJP#%SH$(4dK;r! zXmD_1o^bJWvFxwr(@NZ6JLNG(9!K~aeVyVnqfPY?pheG3x)%k`FbD}``yHu}mbaqr z@EHel8$VqCftSBF28qMmlJ8M^Twzn>_O+73>S!=08Ueg_~) zuXqxE1_Z^l6yC5d3#8^0=+~Ga-BkHuiIhH1Cm#S<0Vgty93bV1eY3dVxkg z9?#a-*%vLP`#H+-c|Hnv!FkW^1!Vr{L!Z7XY$pq*0hr*kKX~C&#I^M%0+ zv>8)L3_ndjdI>`OEPqSce2K~UGQKk~^ zvhaB4Lqe z3_P9WQAqqLLNsT%z3y22O+YSg6YPsdxBbK#$;uXE=pLb9>3yX zS859RojHp8#Uld0?c|#>=fs19BKZn&`tUz{yR}S@^AU3rZPnu|f~7lT?dG)JWw}4nVdI+Dq4+oFNtOJk5cp*q z&`nv)EqirfjyH4=2-{hG`k7-sh%ZI2uZAP@*_&YxA8Lp^U*Pfd!U^Vgdvc{pOP=-Z+XB`cC?I{^^PzmP zx}9sxt*!+?V(KrKVXk_CESiR45`tl;3D#HS>^m6X-c34Qw^=t9QzKu1$V=e{{@)@<=jrc^L8X5N*7 zylw@bpA>(!kE;bpG6QJ^T&0K2DF>8jFalIxbH^6iGwg6lOL)(ejhr_;0QqG8g78&LUvsH@71{hrp*etcM*Sm=ME4WNK$|Am0(Ua)%r zT-9x6VVKKc+E0cs?olxZ@prjp0>I9SVr>jkP07F?_?C8-Wx?3TUNize`JGma0Y9|S zIUQ|#QdBwlx*edm{1@_wkT1>eV*~aw0{W82v9OPnYPF9;R;%fT*2P}TtEVumo5^cj-u!n?@$n85vezY_Z>eT*ejWbFkb|OuY&>HA>G)raRV=@r z29$waoJxO9l-+#DzFaZEBrC4%L2xa$Nn$G7a+=D&N`1sf3ioziAS5cyenjE$OqHiZ zRd7*QqKI~>nj<}P-|hlinT7-Ma}&QK#qeBc7@}f<#3RkrjoaOXcquaJXBl{X(mH%H z_U^mb)^1>Qnm$>yLDCsCFFy0aPl!PP%ugW_;PfHN0z5zf-puZI3Pd*)wAi>_uL+S9iKZKp~N(o-0+DCX^K z(==E5bkO-2UG$ABUYD->_Ptr&YBbO&Q#D=-FJQUm{vn;H2br&i?I`Q{UI;RFHQ>ON zOqR*C6(Sq)PQ{T{2*iaFfwT>Lpf@prn3-pkPP4+Kda|8MOV(i8+g{5}UBESe*6S_S z+jZF?GXW}r4DoutEoux2Z=ruOQG=m`&K9&)xVVU->~MVbXAX#*a6OW4ua|lxrN%fp zk`lZay%m9mQDVV=A)*Vv?hpY_9oIj_i_4c?Z5kwI`)+NjL)7u(3GvS0tTzcgqu33* zY!N!EU%l`hHRzLQmDK1)_{$7m0??SiNQgU*;>zzTMj<9@*&>%nKRjs=KBrAV<-)wl=5rB&EJMyb@U7)O zwqS<0G2Rz@lUqlx6;3jCVABI&3ko&)^(n#4xi92v{{`Ivvsn|=%e;N_Ed4jxQ{YJzNQxnA8X&mJUm@o3aAq&r#xf@%W5?Gvi}m%EO97m` z?z5kK4O7%eUOkeH#1jD~>Y?#s9wYO%qUp@;JvphLc%3cVRMHwD4;w{>A#e3l#>(Aj zc@)3B5viUgGFl?>fwPaN4^%nquqChAwtO_t44vgf?0a;+Igcox1~h`+w-$egB`relX+xrmLP_#Kz zyZbz=&dOn}%_r{u{{HB@?T>#h+6Q?3;4J#_`H4B$M7Dn2FU%wSa1o9PS3EGnEqCMV zwJpxpGo<8%7_yiwF@x216u9sP0!2YC#)|YciA(VD^r?vDvybwrD4fTGzOk8|0EORZ+r{KH7X4Ngns-%Pl*Td%w|Xqr^J?9=4G% z)E2=kINx~uuxY9TXg)4i62iT?aG+tT$bSe7B~j0h_22$~>9ns#=Ny%pRsil?K<`{xqy>U7Co9m>R@KnC$`Bj>e5`g9qJV!Pj(9@6ShE{sDYHGf z>XUN5@H~C$Rcfn6SJphb$@zEx124+IlGo3WRfA~#SiVI)4#0AI^M&R9%MqUVvEi!} z6nj(f^vQSYZn>U;k&td{IDNMv4-Zcd>Z7)h4Lnf@o%9YvY<=OwkOW!_v{ii0~98&naLGi>NX&U4}P=~cZF<$ z3U6IIzI^!0%ck<&^V1x>qW(~{JzIZTgE2t+AIhO>4@B9Sfk|LKq83pep3np|L3fcjMjd9KPx+i^VLj_$2)l zLU`^iteU#}4RM0~JIvIt+#SI$xxyEuplP+?5kQ1POpG3ViupsX!RQ#3m+6-tb)HrV zxpnX~44om`}h-=1a$*Z?@X;iOP+#QK9x z>s$2i3idAWiT;anKY6v$8xk><| zKtvwUz~o}?lqge_H*;nk%-mm}0A3SC$!w60~tyQ=`U8U?zz8 zRP@=M`?fO?So_4$AG|xHL5p-ej-1SrslKksdI+Jnm$AP;b>9es1CuJh0%IqP?NSE# z55>E~_{Wrt>;)!g=dB%+)`g@KY(0Qxw75%nfyqYy)iC;JP0xWhc;EqAzdIJMMITX= zgwaE@=#@HgI$<`e=)Diy(Ph7gtBx9lv%YO!7$GcpL z#j?W?+)c63pZ~2Wy#7;B2snyh0JvQ~*bZbx6Se~~rSI(8@P~V>n~`G_s`Y&t`b%NZ zk;l(mC4>oenGtIwLBIMS1r=v3#f%#cf|o|OAEgbC0&N3;pHfy#!=&(rXYE7?YQXGB z;KCSSo$R9Qwm`M|AY(_Qk-Egc7T}0HV&jZH_WriQ0-QUwzuUk=`s|}yBMHFc|pi0 zLSK5j;cacO9tT^Io^beSN>cxqz2gTRy|5N0(-gCWnMfnqrjc51(y1piEl-#gz}$GS zSMP52kB_NpJ?0poq6pxbx@Oj<2F7`a@wQ(g^+^`S3YU>x$bD?ktD>ybsYu$TH9t|oBKiH%c6lq%i z+T0^om5uE6iXM(eQGY6=!r36H415j)M-vN#8#u2$O74&dEzs`-nm=cSmtyX3A-+~N zZ?HW@xe9{doDF;ehBe+@5it4y_&L(NxB+RQcL_4^Z11;?&}&=RmA>2!Ufg8_xSW({ zL3G|f^)F30E119Zh``D2&op$tkmDjO-6XN%o^co!=ss?k;75u;&0aF#;m++>y`;b> z8*pn(d-)p?qL7$@3DyL?cYO zBSJ}@OS>@MNT6Tc$nm_zY#P4ihs6h?awKDAHoo>ciP-7{H8MO z4mc#Ci=X47>iC{mAg{59AfIq;wZf+Uw}$i4KN-iphZ@rG-xKyO$b)kD=08t>W4=uW z3iddMe6;I2Czi1gGfT1}i4!tMJ{-`S1xZ=7U_F}h&fUl%}SZs-!VTfd>o_@ z<4^5>`79AV@|uwp!#G#*s`9Ix5blGB&>#N1a+^RxlOd3L!nKkosfVaHq%S9)5>MeE zOS5xTfahVg*ZQjQU{#5`PmvR+rHdJJ zMv1uAH>s+$&G?w6JhP*lB5#utf?8YBs}g$gX*WRpMbKhhi_(N~v@Cvpippl?X{2Fh zNsAh~pMA41T5W(sQ+{Acm9jpi^9E+=f3RD1Es>-Vsb8JHLG&6@$kN{;IXpU)m|-yq zj+x8xig*8xGSHg5Yix0TDZ{$9o}5ufgnR0EffK{mB9`X<67_3&6=!Bcm9cF&Y87M- zWRp^%NBk70E_;%kqC0#M>$d}GMkSAQewhBBeh=>jit?*ZO(vz?2xS6tVC`KtIc)P) zg?=4xbvIYKG*eI+^Ge@TVuW6*Hj?>`3%bmKR-8_UcRotQFM%IGUXCjykYCveCH2oBK`P-5kxCky|llM2nEB4tZKiu)e@Wx_Pv*aU|eMADf=G`8tV}J?^L7iWpc*XNS^!|4V=O1GIGd~|5 z3&G=NCZ)(sB|>wimUoIUvS%xV>oa_`^|agWSQ~r6K^x^gyHQzIvDi;(a2y7pvpTPDgvRY^bMmXY-UP)^Utw@>Ur(8)dN`Ph%;=$P{WU_2A! zFfeoT`cM=5S39GRD_tXV%N2Fr!;(f^hHz9q-Wf$oA3>oY#g`-?;tZ~j70|Um8u<2} zN8-J0s#{JtaI*@Y^R{LnUm=%Y@`|64E>jm=7r5pa70NTJdwde8n>4*h^?j)4V41dR z@@^T}g!{nrTc5JNPJRV7w}h|gsgH|^+56DFP#o5kOER;vkui93?D1{omN8VN4i~!k zmScmYt(6&afeZQNfzuy#>9#Worobk^ zqB(v8_FhuI6yOnH2sE{`Y2-6nU7Iz;+As}+V+AD`H7WbBE;=NO2z(;#2_ZyS`j_f^ z4uBz-LT%WZxbJej+RsxwPQ?f6nL-?3xHaMCvh=#Y^&E*@-V{#5R#Yk$ahGe#@|djC zM^peW7@wC2dtSvr9~eR)_h@wuGS5+%L-cY-p-jK?@B;w#NZc_vBxUQilxFl4G0r+# z-eYc@%GkwyN`BCs zcu^8-ACY(gxkRN6MyYt2IRKv{V9P_5wlVpU5L|F5kfV5_;pebvv7H`sbxxt|A^J^46}Rb z#=}={PZp+c-c26jDCM{3TXMya=5_>l($tgvlGIVi%;kl653b<@A3O{kng)gTuwb;n$k1xJ-j-M38*87tb+DPCa_rbx=|h|qEr~I0d7ukjip+Zg7!VWC zn+wzU^OBFbtXlW7R8))2k+_0Matnx%Y#`zp#e0XOOWFnWqkp?@u0D|{gQ6|Aj1YgC zxv{Upwl_*UZ*f%Y3-eSOr+l6~WVuUTv#BFKS$v8EHi{>{>_BXBoaIyLF? zAq;0q1`Q++6D*Z4I z?{8x3;ev)i@Z-CU*@+=wFyKDBg=9Z1_e;?z(1Q?(b$8ecro3SnWhyOhp_&Z_*ivu! z1mtfm#Ok{CUaZgEzYXeT*0Zg*1HK0FCHz+26GPoiyvDvK&jO{x&mH=)UG7R~tImcw z5Jkt~@2ggv?0wW^mPz6io(rp2Z*@jBmubr;4Li#icm@@%Nc;*)A3iYI91 z%E5|VR-osA55b%T8)F)%oG`#7Zz8}#+aYaR#l>PAMmr(M+({5utWP?)#C3%8i}hfz z?9yv1xKOMA4kDC(oUhx>K^BAF1stupvTgWHp+7h2z12mzPCQaAZBg?Pe8g2v4{{|G&p_!fT~~)mwg-m zD&f@PtB1{B|BJOb>=|R5s$&s3?0KQ+tJMkno1K--wc zv#MHLGj1mfE+aAgS5shns)f$+YmXC)WXfiT3Gj&`22E_KB9O?bqN-a0(5M&KmiIB! z_673@AJ&XdlrS^{ld7lf4#Q|MG52b<_$7%|{V5VwF?qOn?mNmBhJFfkwA)U&0djFq z<)qyfRezc%n5%3l4dnnBf*?K7F`z0LHN1J6H}=8rt_kV?X?&-v{tfe0CoM^P%0d?tI9T>5 zdxPaS-tczanKGn*RiP%Ky9N_j7$){iJ`)Z9EbNtzsXpTT18nd#Jys}M*%;rdQ!boL#}j7JdG#F+j;XwD-FO6}4}wS(7rdWFAuch5 zp#yC!Z!gIi!ON`kx8cB;FeSsyILDDBHv9{w;yq7ho-^>tC}2dE)=PKU6ffd|N@4zO zNOrcwJ+S*rp81c99+Js-%crXz-~n2&9I$29=yqD9=mn5LOa8-3bV2SL1AUa_tXmq~ zSKIOh5;f-QRG9)1e+Yq~-@KsKsLP*ij^dgEE7G=3!w-ej7w;}gC>k4tYAKFpxo3Yt zbd=m}T*}YYBYg+oj%$k0V>;rwLdlHO?czDUr&~p*bvys`VIz&eNS7{mSDQ>PNg_v@ zs}BqBN!05sQLOog{~iRFplsr|l(_=O^ejGw6~h-NrX-$N^5FDwzwo^CnOq-Q^N>>^^LyVQP0+jl zKoRnUL442vnIoglBYzYdekqzQqHF?7&Bmr_fAu0a>HhK1=yXfRW5cTWHQE3h-&vfp zMiZA<^)=>&cCLApHdw_w1vLTmSK!|-#!BPX-noB`i{fBnxVJ^mG#)?2j<|gE;R94s zwdm1X-Qw1xx()zL9SY4P-;;ggd2W-@5{|zyc}F zoAuz9Ve zqNnTFS`S#9nRM$bQvlEicSuIjlADK~#AYSzwyLlzO8Pi1#K77^W-R}-fj2-sbIN+* zdXQQoK+N3Go=?VQ;F)=s1!cn?z~p_>Izy)@eT5l7tR zFKfTJyJpHWF)DUJkbM#qidR;8%ZVF>fx&Dy?$8sp7%yyTC9GwYI4OnOFJzUAkDsDV zj-A7y8qOq2aXvvSx}NG=V#0~RZyd#$NUlUVqh3-yueob@fle$)sA>pu@u2fgFZW<_%B7s`*kkZgw1Bt&DH^Li!-$s66v zyEl3wOlq>}sw0J|J6aNN=D=LDT_SKw7x10oI8N9hyphx90K11eSEC1d zM}RlMMr)hba+^&j7B>Rev_Xkdh(MEwj1f;#YboE^+Ug>kaG^suUF$9m)I)*uj>`RA zukP6Auu)N7tL6iRp+t_q^k!4;Udd?>V!k*K38Y(KQN6Mw8l^3-iSlSty3h{hZvY9J z4-#DYO}2IZ(T~x)^rqq2m*?AEsj{lu!VZV|l_yi(CCEM@0{$K!pDbJ4pe>0yb-{X1 zg%6{@i@0mRunkRu5<9=agsMZ}xiJnV=w9MSvc{V#Md*k&NK%~e+CxTySE1rDI1 z##?2K#7MN(Phz(&A2xuCS<5^(88gJE_0hXLPDr4U6qR{s3R*Pd=hcLb6<6<{a0ELm zr89WREoXMJQsr~pVDWgSJ?AHJYA$RIg8yhc6z0X^SQ4)m`T)+P!?Pt0+-KypMG50# zMJ|g&i6QEhJ>-$@27f^?6nq!XUHDCg^)Hj%C4m-HUCfBS|aok6} z&jt+PYvj#J5mbx)Ah*F$iMY+Yji_MXYbsVFfZh5sdC1@i_$o^WhPg>68GkI+p1=o% zD@%n4(&A-^G$!jcBX{M=Xj^VY>o?B^FnNlAFTv-8{hHiso*%s;JDj}c)r<-=!B!+! zIVt%Y;}W0Od@}I(kr%}|O^_qE5~4<$N89Q7l-Wtd$fF)mf8ithPDMW&^6`d~sV(dm zMcbL)DEH^}T5K7}ebaavjrohV!<$8HO12>3=W)MN(_nL0AW8rDCVwikN-d$sJ6e?( z3JOjldT7pa9h|YHv?{%Os|iCpS}OHweAT=RWKJ^{&nniW?{`s^1v8itOxJ}`#=B*R z*G>kP&wjDt*KI!w_-2CbSdg-4dmsqR3sba#n#U*&qo;y&Tz8X?L>tVjdnyez zj}%@^64DoXJoYqi@&!i2VbhwHJdVOXWtR;7_1$id*rLI7)5%B$_7H(Icj8NJ8b*8> ziQj2^3B{^>2TA z-GQUI%(>0=^9UR-x}2G{S0=jff0ie`(jK`u=U1m~)RhHTOo;g1Zt@6 zX$8SRT3_!1n~*x~=?<5SLCPvowJD)5&}yz1*qsLl{9t!2Yt1;&HNOlN^!tNjEl$@Q zMebNUAeuT*?%@hyCyZxCmb*URZ!)Aw{D2^E)4k10&TBpsiV$2)up!!j+dk+E? zx>{MOv%aBbz*WP1;X|y@_X5riT@}HIAZIUAd4wvO`>Ca;jaJ+{&lFUlEzo*H42=P!O> z9$jMVhaZ2JGlQMapF3$KhOJ>+2hxUPHflZE)2fwwR;MHm?PF;YDRE~bFR)H&At;`^ zZhT@etq1Q2nn|O3hhKh}RSj-KYX-hH^*|OCeX5I?%G(&9lZIiil3*{$@u#@SoF{JU z`!m)nq{{d9BtUdJE9rS6S@BD=Q@8b%wH_z*eq&Wl0<)6nq}68M9I)DM!Q%~CvWtEG@pM*NJ@x7Mh}J5w z;&Mbr8t@(9La%HFCJachFDiKZoC}!1&V3`gaFJ85KlD7G---}ziU=|dj*^bFvRUQv z8rQ<28x5(gs&Lz3O?$!Dp@RuN1eJ%!IB`5RU>q!-mOq*pGr(yusC&siwS3Yv;!=Ky zGbHI4@lgU6ysr-u05$h0m zp{_4|Y~E0f(_dG-oW7PBwX3vDr~c0qjD5bTuRLo=pGe?^uR!mVrVw34F&}+zNH^jN zsa;cYA2)nm-qH#c@}h)eOh`;oO_0iFM#@>E?klkdF?k#*Gw87-?_J*umEiWHZYWZ-xF9UntJO4ST8LASGCr#;M9(<;-S*}UIgh|Y(tJ$%J_w|p+z}?bHqQ%WH{ z<%5nzMlylhUWX{v=_cttgC72kihZKqM_T;(0+<9us< zb}#PVXm^4m_Z7}X=rPO3PR(S?$L_LV+$qMFKkZA z-23kMCh4idBALf?ZGY7CK%BzgNAXrFqv$W@z&9%=M9=&3qc^3?6BWmVTE)nn|Intz zru3?Cd+BPimOEndAn1e&vs_;nF@YhTCzUq5FYI}twG1TOVePr(wc-b3;>F55ywHCS8u}{wbYJdHIPCVrM;W>;>1g_wux+K4??I34>yCB= zvZXDNMF@D$D8dgDv{%i->-3Bi+x3wHoN(f$HJ;ebkH_H*HLy3VyC2%eW~h^Pn2(Cs zOTcti&x;BQQbjV5Ja&~Qgcy1xpqUtqM^?Eod}gHydMroYM{HK#l8ORtoNzFC9%Jq; zwTboyzqa(6<(G=Kmx^!(Ht>)T#_W8#4SkTKK*mCqK)9w z%_*z%)@}E3LHZ<{$_%5DA)5i2lHcC?gG`aaOtD+O*+-@2nd;)yJb$q*xwLc3l6S)d zWDKT3y0iPC-;Cg6TJyGy#Le3S6?9>bj7ox9M-X(reZl|N@KO{IQ-3$5%P8qKT8c?YJ^oJZxl;(TvEG+0Pp zGo(J@H|9IZRR*&dAb~^;rYgeT+%gHKp#AfbY)#tL;00qH4M}hYXT43?L#ZqC^2n5(E@Pa?Uv; zVaORqau855js!`PgCxm8KqZSvh9PH=IApfR_xpDL-P-@(+O1mZGF5YDrf+wjbDr~@ zbNluQNQ#brgvoXdYk{)KkFx%?L>wgn3uiCdu&~)W`?r`;pbnLS+}O1Z8WBM*NgrfY4do+3{bU6;YDH^7=}GsK@`k zllYdMGsIyB6LPzk@wII>rmP4?>+WtOGX1*+Rl$Bg%RQsT+_%EO=CFC$v&K9H?l|O` z=)vT~88r}IfHzLXG6oI0mpQ*lSkb0QEEV$Zx(w(leC;%kC7|?#PAD|Qf3Jc=%vnwT z>6g`cqSw|mZ8dCpX}$Z5UF_o<~&7c~@M zKMkcZc^U)7TqER1Z}3XG{$#Gn9eK>Asm#qtmZ*?K#a2hy#~QmpHGr*Tsu+ZUA1)oV zqO&VH5T3T!tB#lsb(Eg3IQXnjsFj;Jy~&s)9AYnpu zV~Rj44gSY7G<)FBVIm@WcQ;<^d!LN{+N_MI<;nx4clL5^T#|M62%l}zDonhAG(%~u zpw2SjZh0LO=ZmySuG|r+5}Mqv^DA&3riYQU^E#{DOSH74Vsm78bl%T0UCWp6LepQ} zPxR`jJDxm5QPyk(%3|s%sLnwqg!3DQ)=B<4`tE6;KM}YwvGuf&dKvXxEQQC}T#v9! z%+ubJwcL6Lf*Dt^+74OLvs9%112Y7dZ~b?t+**s90K0qYKzRvx;MfjP@5c5slf-gC`USDPF(^UAMjwmMqiQc!HiU zP$*{K^V_Z7Wx3r`{^kyv?Al33sS~S`#aCf466F+LW-MT5OE;AH0IEK{5IEvyhfqKT zBm8GlrM&@EX%32-QezgBK-mn#wr{;HZkt+aD)^Jghhv$RaVg@8`E)SW;71?+N_*Rj zD4n+WY}EvlWUF%J2k#Lff;bqGBcIidWGcENVODsGJC7TAm9El5$Z&HXeSS@nX~=J$ zQ7VXhpybi{C8fxELcq}KMt(|BLHiKjTteBpoG^|tbiZ^_1E=fz#287IkV5Nc{ZNy1 zk_c=K7a~Ms^68VFyReRv9+YZs@iKB#l-%6Jz3zX9vH|Iw(N^ocrJ(-w53LAW{} zlfyEN@c|Zdm(eOBa`Lp|ZcKfS+vnQ)9aR?e+rb#0GB~zrc z;SqljTXXLjn~qdB<~pn&EQ_wf$tg_Zk)fN`F7Ctu0lj=-QD~P%T zN@#wI2)PAjES5qIVHZQja^D`B7+;~#_&kgN>!&)x1&ggy)q;Ws>*f2lPwI<_Y?eKW z+U8_%S6fYO1cyxvj=De@oNvbVB`={l$%yXzF#qa%2_0+I>h1Jiu}&lyxcy^2Bh8|UhX2!eP~89A0w*G#C`V@Y?Gt62)1BkvTi&QiJm4q0(PYYNUvS+ z!sTph+EBJ|l)AWUgl$-?k&a4o2Q711XP*XRgd!f)YI*B@8m((;+K+&5@pGExk5HzW zqUKCH%A=G9L9V_H#y>u$$>wuD>&>o%w>U;*P}PrOgOu2D?k|r~SL^bfGbsxBG>@W; zb>-2K;og}BB7(90sea5QL??fL)&h1Cd(-YE-N{-YMqxcuR)$w)b2uM85w=py6w@wn zkHCEs0$B?VJ0gf}$WvLRk4>e5S8^-w{-p5<8%br^YWrSne^9!}?|;mplOLL_`jz(gehnFIJ+*MGrp3>`aX-Z%NR@XSIqjdg+yL)_JCKX zg+4n1N%AZ8mK132Ui#_F!r|eFviWS2H-4y;PL&10ELf2C`rK)}0^?;e$J6^%9RzHM zAnQ#3W4fAZAD!PZCg~rPVLz;8xdfO-zS4<2C%xtG%odx=iA;PMyn?+`h;Z`a_-^vR zQ|vZIex$+;<)l6qKn)Z`1_El&G-E2q8Mo|PvDr&8Dkz2${P9V*v1fg5u(;9%=`SWy z3kfH1ux~bI6U7~frLXl@P{3ENK-g^$hbxQ2iFzD^gsk~8e- zJ1yvlu*jpeQdNOrK3a@;X@kg~86tz>{@jZA;Gy+GyZLN@o5g2kc`fckSey_4VULou zlv5!>SZ352^K?aJrEz!4Auc8R^0@U&b@1>&o}^*1eSjC`b{coZUrkiutY!v^ zYnAB0#e9#KW?CB?8Rky91)Z->SIv8qIqOlgzI%(z*L1DtGrO^{-iL2USVacUX(=00 z%u;@6FMf3oNsW9gK*WQ5a~4V$-S^FR#iwV=#MP4`@XV}D82;J0SpUAUYC+}23fXHy ze75DVr1&bz=&tym43z|gJXH3T?>W1JPHsVP5^PQ8ah-c64d`kybL>aj=)%kDur)G# z*l!_f;^;<(z6qzA*;up$eZOq9&G2XT`PE|NHzfXIRSns9jS=#`>EJoynI3~MBxjZ+ zC}-q@_&2JdF#cuWc^*8ewkLY|e*D`N#9~uWR$ooUPnL6odH-wD{cm`+qo#7NVa;?Q^B3i$eixWGhYq`GMT?}Jzgg~BLoh*8t zE~o7E@eLy1%HI4waXn$3*|jzCdGBN~4hy0rcBIjCzSDTp#T@{53Ot|csamIIqYx#C za^>l*vPW?ENXB)7oplA$Tdnl-uwWCRxpeS2lYYebg;7X)`p{$4ou=P)q`?tp6Y-%>U5SWC zB)Z6(iKR1Ng{!e)*l~$ZU*a?*c=+f);Ejrtm?E&cYw{petl2hX^wz*lm5ArtEhlFD zp3+j-aP#1|zLV+c{xaOb z_h$P$Z_FyDCUJ2WQBKV3^!M<>vtQ+8u@tt;ZqPeXdvVx2$ppM)(4hV$B47bdlyl zw#Xxt=VHm_i|UxPal1FjXz3*S8`d}1yS__bwzXdqhK>!t8^?g0Sa>o+rO!=5MoyX} zVpC@43@p&lRe^uJZ0g@Q3i%s761bSh+`UPT+Bso}J9i+t*j^Mmhs`j@sbTCsItf zCdDy?qGocWSbdM+m-^chB*{2geS5ETX%t5KPQ{SOffFnaKH}c$EZ4A8mPofr>@43N zi)(-W5QcOf|Jg{PKYL2}>~EC{qM0@9g-r6NkH&6G3iY;#E4S*<1ly+ZjA#u95FT=; ztU2h#taCDE&yHndV})oPGUluCa8lYTT==TVw^wo8zrQtuGFzF>f3S@(Nc49o&+PjV zQ|_nXazXJ$nOwxk<+RWmmGwR%`LBKLUlpsta;PF!}^ zG%O^okz1WS!VN1n;&g3FG|0w=NLK1}#2t{APvmq4x5(d^?vA@L{+fKdCKjU1(Wbz+ z#iTBG=b_-)k%O~0n{KcWk z8fxKHi{Jwc=KySGM_=YP*}F_5qobi-Ph#J`B_|@{zn!ZjdH&5K#+EPYIALp3dP#-* zc|)V=%?H~kE@r9Rw$rD(b2l)p8p!1}SA7@!$PlRcP6vIASLHth3?2vsL|*(yxl3Qi z#>Udjea~JICYwljoTqWs5RG}hI<>Pul6ghtISmU3w%-1AUbP)9?#lYug|f|y@s*l9)`Daove>N3~1gPq}wvqf7?{FFvjiI z&8%_ZGuJ=iV%1fSftbJW_lEoLA91S+-#|Gn%et7hz+%d^{cSG(yHb7%Ebg_~FcxGe zrLvR^hut}!NI{Bm7-=gS$#oh01d-n9c*}>Du%Z zC^h&!;gOSj_Ejm@uh!Afv$_T_@|5pGt;+_jR-hac7yW={@ZgA8Oi7>Ant}B&oq(c7)=yB=uH!BKqK>VX9>9y@3C_4t zLPYy_((TLkj$7CB-&gpe9H+sz(O=5&-4QO)tGVGh*AB5?FS6i`6d6@{Hns zbfjX3WXHR6aX5rDCfk!WseINX5R>bxOSr%Xu)#)njs4id@sv}Ky0TbkY%Ix>y|0w& zvr&kDH}zeyzn{gi<}?gK3^@1qP{qE1zM1&X5heMTWBmO@hWx%WI&l7b+{eU0 zC)WQto_#vStnY#5Q9(?coh!OID_`WP(J?V~A(6NE6^q?nV@3bBazP`}qqMWJHw4pk z*<^tp@R6Y*GKk6V5?ujDf`7N20ME{5;pgY4nhq~i>nL8t@2#qEniKyuItu62+FSt_ zB>QaD-vKCT?Ah6wp5SVI@IO-jH_rWsOD7ZtCaD4Al#-Rj6XG`LIK%30|=FC~+s z>gMK#1jf@2c5}d7t^dBd6NJy5t6crJP>VGe|cy+$p15AEzA)4E4b>Kt&R#mUd zaWi-#9LxMnyY+0e(&j3+VEhCpN`lnpB38Nb>Ik(73cc+C`Ud9>Lz8#-rOm}kLE`Cn zVj%9rkM}ORj4whP048BhDG4uAxetn=etmk@LnWzfs{rdPUdOyHQH`&hKUOi6y>{A`*&A8&QFx;c9&x1E}Xl@!$`)rnOe5F*@NVa6p zv)Q^y4Eco~-R@jo%-GdcK%Q;7Ub9b4-5_|JoqE;aaxCz2jMx5L<5pwf!CsHVl`4h` zs3mrc#wdju(A22IG)%JPit`wVSzjbCW)9ReG%y6p0(amKc**7~?(yVF@C#TG#&-*f z_m3Sq_LqCHrc$_#V?kl4-=8#lNU^Z6AVDiDD{aR|n`7qPG4w*GO9?RWnA%5Bf{3R7 z{kyHn8bT%}rc^lJLFM8+J%{~Fkc6y{udiwPJw1JW ztSNnceHgM04z1ZZkz@}Q-Koa{MdNOQOCcSME6s3P4nFLf3?PKpc6PciQFC#i{xuz# zhjf=>EoS=x@$**~D}t@T(lWe2sx{?;fpNO>WT@ zMLj!6NXzwAcoh*$sr-bz_3Eg+`J)B2H_3FgNK*$)2f(Bz2Y!!-gEHL@->mP;0Vvrh zDmKxj$pB{CW-U1Dm4iBXjYH`C^97sf`p>-aCT~6(ZX>^v_ab?zYX?EyPN!%OUJtgY zBfk-fIc0m1-0gM1Yhou6%&u9ETm6@3Pzs{}&ybmyS-)75mFQr;`h!=ZUq|xc!v`Fc zgOgJay3h7wW#+#c7Q+F&g%Z-5jg=W@G~Rr(oMVmJnejRr)rNHv3sOzTb?YJ0ir1b@8u*Q(dXLQ+L8`GdKS8(vu&Yo)(PS-(PlsovRcFdrE}H} z=(6_S$L+0{_jLY+x~xr+WDebTteYP0?(@LzOI3^Wx#ZcWU3xja_PS{IfH|9jl}YF;D_6dg#bqB(7qk$94zMi74BVd}=W(pkZM4`SaN%kI~a=sZ(P| z4f=-0KI)m2Zl^Fapa~1~2CV8)624mHMy33U>cv{6YRmyA*$vyZQyTnGO^~P4Eq(uZ z`J|mRAPWkG{yIC_90icpERmCwBhQ`(aP}9d23Gjkar#q3W8-Lp`{pm88#z`3h(cUE zJp1Xh?}O;if0rAVi(ek99|5LR{F1v_V{~-X+x%!)mRXaSn0TX$)>uQo&QUY)Krk?8 za%!s3ske<^QNZ{3l{;$26R&n;oHG+}iyF&b8uUMoq!_?_JCMQ3DAor6p8wua4ak0D zRNGh+&?+rjW4}thYMZz61tT>Lr7xuadbEwIUM_X?x0+G2giqoqBSX~W3*#iNbS}57 zCDeDD4q`WUcC_q&m#7vXT%tq{`uGY1HRrE5kGv%pJ^iA@m=o3POiU!7-6lT*shTB5 z<;6Olt`&26#Y<}*aC3R7upmRtb)`?Wp{%$onig;CbL3Bqc+}v*phP+NrJI`ur*Vsc zVy3vEZF;`dU`AP|eZV*)kvj0E8P+56e`5^bW-9I9`hVX~QZi zEmfos%jT*_V%E5C{)X0iZS3v$azBLF^~5s4w}G3to@sFR&cqut@-0;>s@@ZM{5aq7 z%QDUA^mIwbd_@EB`h|l`H;$YYd7`Ku|ks=!6MC30_{}*=Tt{9%yW1cXv=Yqua?es=p^O{cO-AKT%DS z;`6`R=B-%5Pu+i$>*zBd@&AAE*sQj{7x`gwd3IzHlik|d`dg6&Tr!sB|8PYG_C&Rl z)4{-4N+ltTd1tz48qSWui=IHpx7^`U;19riDUhZHNw_y)=LOt>y~epql7h?t5u(mE zumQKA3W-;dZE8vU(Xg<3`(f(yMBbrInLj%}k)h@SC5*i0aduDa%f8?iYnOKeNQQ4u z)h&X~KjWYwtX^z6-|6HIJbj7IAcAe6&Nj;>?xB=HEbt2#h^@x)FNsa;`1TE7Pfza; z0H=8nW$o3@Id>AHqk_4s?YV`I(OexHqs5g#MKrRt62fn593f~{pBQDS3kedi|826;mj)js>cq!Zp5W<*j0>pk402s9MLP=_sOj@7 z_6pZci36QpI0^o{GS2LW^Q3J-I}Z^$$}~RvnSvPz{N(aB3SgYC1nTI>6mUeL3VXuOut7VWIFZEEF8Tzekq_6eb|53J$+3?M*tuWr9}s>I?17+HXvzm zaPW9NjMc1?4s;C*;gYXfHQU|14E_Pp4qhTZnII*bWWUj6exd2jrKKwiv9t#9iyQP3j%z2 zOyD`FdME)N@IuaqGe7tB6}{=R#$o`*G%Jwdy+V&}p&rZx?BtJWUxpY15Rnt7V+s&@ z>Yeyv^kR3|G*V<1P@C+^%F5sUf6bZoKSz_l3%&orohZpDw0ZqK{)^!EU!d{-icEj5 ZF|aE(6^?d~X&~V5#WN+DGAWbS{|%?4%ozXx literal 0 HcmV?d00001 diff --git a/iris.py b/iris.py index 362c611..b68a894 100644 --- a/iris.py +++ b/iris.py @@ -1,22 +1,24 @@ import os + os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' import tensorflow as tf + tf.random.set_seed(777) # for reproducibility import numpy as np + np.random.seed(777) +import gc + +from pso import Optimizer from sklearn.datasets import load_iris from sklearn.model_selection import train_test_split - from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.models import Sequential -from pso import Optimizer - -import gc def make_model(): model = Sequential() @@ -45,7 +47,7 @@ loss = ['categorical_crossentropy'] pso_iris = Optimizer( model, loss=loss[0], - n_particles=75, + n_particles=100, c0=0.4, c1=0.8, w_min=0.7, diff --git a/mnist.py b/mnist.py index ec2a910..0ad100f 100644 --- a/mnist.py +++ b/mnist.py @@ -59,8 +59,6 @@ def make_model(): return model -# %% - # %% model = make_model() x_test, y_test = get_data_test() @@ -73,12 +71,12 @@ if __name__ == "__main__": model, loss=loss[0], n_particles=75, - c0=0.35, - c1=0.8, - w_min=0.7, - w_max=1.15, + c0=0.3, + c1=0.7, + w_min=0.6, + w_max=0.9, negative_swarm=0.25, - momentun_swarm=0.25, + momentun_swarm=0, ) best_score = pso_mnist.fit( @@ -87,13 +85,12 @@ if __name__ == "__main__": epochs=200, save=True, save_path="./result/mnist", - renewal="loss", + renewal="acc", empirical_balance=False, Dispersion=False, check_point=25 ) except Exception as e: print(e) - -# pso_mnist.model_save("./result/mnist") -# pso_mnist.save_info("./result/mnist") + finally: + gc.collect() \ No newline at end of file diff --git a/plt.ipynb b/plt.ipynb index f4b5ca2..b151d8e 100644 --- a/plt.ipynb +++ b/plt.ipynb @@ -2,40 +2,38 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 14, "metadata": { "tags": [] }, "outputs": [], "source": [ - "import numpy as np\n", - "import pandas as pd\n", + "import gc\n", + "from time import sleep\n", "\n", "import matplotlib.pyplot as plt\n", - "\n", - "from time import sleep\n", - "import gc" + "import numpy as np\n", + "import pandas as pd" ] }, { "cell_type": "code", - "execution_count": 57, - "metadata": { - "tags": [] - }, + "execution_count": 18, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "(33, 100)\n" + "(39, 150)\n", + "(39, 75) (39, 75)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -43,47 +41,140857 @@ } ], "source": [ - "iris = pd.read_csv(\"./result/mnist/06-23-06-43_50_200_0.35_0.8_0.7_acc.csv\", header=None)\n", - "print(iris.shape)\n", + "# %matplotlib inline\n", "\n", - "loss = []\n", - "acc = []\n", + "data = pd.read_csv(\"./result/mnist/06-25-01-20_75_200_0.35_0.8_0.7_acc.csv\", header=None)\n", + "print(data.shape)\n", "\n", - "for i in range(len(iris.iloc[0])):\n", + "loss = pd.DataFrame()\n", + "acc = pd.DataFrame()\n", + "\n", + "for i in range(len(data.iloc[0])):\n", " if i % 2 == 0:\n", - " loss.append(iris[i])\n", + " loss[i] = data[i]\n", + " # loss.append(iris[i])\n", " else:\n", - " acc.append(iris[i])\n", + " acc[i] = data[i]\n", + " # acc.append(iris[i])\n", "\n", - "plt.subplot(2,1,1)\n", - "plt.grid()\n", - "plt.ylabel(\"loss\")\n", - "plt.title(f\"loss and acc\")\n", - "for i in range(len(loss)):\n", - " try:\n", - " plt.plot(loss[i], label=i)\n", - " except Exception as e:\n", - " print(e)\n", - " \n", - "plt.subplot(2,1,2)\n", - "plt.grid()\n", - "plt.xlabel(\"epoch\")\n", - "plt.ylabel(\"acc\")\n", - "for i in range(len(acc)):\n", - " plt.plot(acc[i], label=i)\n", + "print(loss.shape, acc.shape)\n", + "# print(loss)\n", + "\n", + "fig, axes = plt.subplots(nrows=2, sharey=False, sharex=True, figsize=(8,8))\n", + "\n", + "loss.replace('nan' ,np.inf ,inplace=True)\n", + "loss = loss.fillna(np.inf)\n", + "\n", + "loss.plot(kind=\"line\", ax=axes[0], legend=False, alpha=0.5, ylabel=\"loss\", grid=True, title=f\"best loss {loss.min(numeric_only=True).min()}\")\n", + "\n", + "acc.plot(kind=\"line\", ax=axes[1], legend=False, alpha=0.5, ylabel=\"acc\", xlabel=\"epoch\", grid=True, title=f\"best acc {acc.max(numeric_only=True).max()}\")\n", "\n", "plt.show()\n", "plt.clf()\n", "plt.clf()\n", + "plt.close()\n", "plt.close()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(201, 200)\n", + "(100, 201) (100, 201)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n", + "/tmp/ipykernel_679434/2716345891.py:22: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " loss[i][j] = float(loss[i][j])\n", + "/tmp/ipykernel_679434/2716345891.py:26: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " if acc[i][j] > acc_max:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0492493547499179 [] 0 []\n" + ] + } + ], + "source": [ + "data = pd.read_csv(\"./result/iris/06-24-14-00_100_200_0.4_0.8_0.7_acc.csv\", header=None)\n", + "print(data.shape)\n", + "\n", + "loss = []\n", + "acc = []\n", + "\n", + "for i in range(len(data.iloc[0])):\n", + " if i % 2 == 0:\n", + " loss.append(data[i])\n", + " else:\n", + " acc.append(data[i])\n", + "\n", + "print(np.shape(loss), np.shape(acc))\n", + "# print(loss)\n", + "\n", + "loss_min = np.inf\n", + "acc_max = []\n", + "acc_count = 0\n", + "acc_max_index = []\n", + "for i in range(len(loss)):\n", + " for j in range(len(loss[i])):\n", + " loss[i][j] = float(loss[i][j])\n", + " # print(loss[i][j], acc[i][j])\n", + " if loss[i][j] < loss_min:\n", + " loss_min = loss[i][j]\n", + " if acc[i][j] > acc_max:\n", + " acc_max.append(acc[i][j])\n", + " acc_count += 1\n", + " acc_max_index.append(i)\n", + "\n", + "print(loss_min, acc_max, acc_count, acc_max_index)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 1.50188923 0.21273327 -0.60860867 ... 1.25524983 -1.87869589\n", + " 1.57006041]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "[6, 2, 3, 1, 0, 9, 7, 5, 4, 8]\n", + "[5, 9, 3, 1, 2, 4, 8, 6, 7, 0]\n" + ] + } + ], + "source": [ + "from numpy import random\n", + "\n", + "# x_list = random.uniform(1, 10, size=10000)\n", + "x_list = random.rand(10000)*4-2\n", + "\n", + "print(x_list)\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "sns.displot(x_list, kind=\"kde\")\n", + "plt.show()\n", + "\n", + "x_list_2 = [i for i in range(10)]\n", + "print(x_list_2)\n", + "r1 = random.shuffle(x_list_2)\n", + "print(x_list_2)\n", + "r2 = random.shuffle(x_list_2)\n", + "\n", + "print(x_list_2)" + ] } ], "metadata": { diff --git a/pso/optimizer.py b/pso/optimizer.py index 1ae7938..92207cc 100644 --- a/pso/optimizer.py +++ b/pso/optimizer.py @@ -12,8 +12,6 @@ from tqdm import tqdm # import cupy as cp - - gpus = tf.config.experimental.list_physical_devices("GPU") if gpus: try: @@ -37,6 +35,8 @@ class Optimizer: momentun_swarm: float = 0, ): """ + particle swarm optimization + Args: model (keras.models): 모델 구조 loss (str): 손실함수 @@ -67,7 +67,8 @@ class Optimizer: m = keras.models.model_from_json(model.to_json()) init_weights = m.get_weights() w_, sh_, len_ = self._encode(init_weights) - w_ = np.random.uniform(-1.5, 1.5, len(w_)) + w_ = np.random.rand(len(w_)) * 4 - 2 + # w_ = np.random.uniform(-1.5, 1.5, len(w_)) m.set_weights(self._decode(w_, sh_, len_)) m.compile(loss=self.loss, optimizer="sgd", metrics=["accuracy"]) self.particles[i] = Particle(m, loss, negative=True if i < negative_swarm * self.n_particles else False, momentun=True if i > self.n_particles * (1 - self.momentun_swarm) else False) @@ -309,17 +310,23 @@ class Optimizer: if renewal == "acc": if score[1] >= self.g_best_score[0]: - self.g_best_score[0] = score[1] - if score[0] <= self.g_best_score[1]: - self.g_best_score[1] = score[0] - self.g_best = self.particles[i].get_best_weights() + if score[1] > self.g_best_score[0]: + self.g_best_score[0] = score[1] + self.g_best = self.particles[i].get_best_weights() + else: + if score[0] < self.g_best_score[1]: + self.g_best_score[1] = score[0] + self.g_best = self.particles[i].get_best_weights() epochs_pbar.set_description(f"best {self.g_best_score[0]:.4f} | {self.g_best_score[1]:.4f}") elif renewal == "loss": if score[0] <= self.g_best_score[1]: - self.g_best_score[1] = score[0] - if score[1] >= self.g_best_score[0]: - self.g_best_score[0] = score[1] - self.g_best = self.particles[i].get_best_weights() + if score[0] < self.g_best_score[1]: + self.g_best_score[1] = score[0] + self.g_best = self.particles[i].get_best_weights() + else: + if score[1] > self.g_best_score[0]: + self.g_best_score[0] = score[1] + self.g_best = self.particles[i].get_best_weights() epochs_pbar.set_description(f"best {self.g_best_score[0]:.4f} | {self.g_best_score[1]:.4f}") if score[0] == None: @@ -420,6 +427,7 @@ class Optimizer: "empirical_balance": self.empirical_balance, "Dispersion": self.Dispersion, "negative_swarm": self.negative_swarm, + "momentun_swarm": self.momentun_swarm, "renewal": self.renewal, } diff --git a/pso/particle.py b/pso/particle.py index aba9627..064a80c 100644 --- a/pso/particle.py +++ b/pso/particle.py @@ -114,6 +114,8 @@ class Particle: self.best_score = score[1] self.best_weights = self.model.get_weights() elif renewal == "loss": + if score[0] == 'nan': + score[0] = np.inf if score[0] < self.best_score: self.best_score = score[0] self.best_weights = self.model.get_weights() diff --git a/readme.md b/readme.md index 3af9a05..653ee75 100644 --- a/readme.md +++ b/readme.md @@ -147,7 +147,7 @@ best_score = pso_iris.fit( ``` 위의 파라미터 기준 2 세대에 94%의 정확도를, 7 세대에 96%, 106 세대에 99.16%의 정확도를 보였습니다 -![iris](./history_plt/iris_relu_acc_200.png) +![iris](./history_plt/iris_0624_1.png) 3. mnist 문제